Chris Maiorana takes a lot of notes. He’s a writer after all. Once he’s taken those notes, he wants an easy and convenient way of viewing them. These days that usually means viewing them as a Web page.

Org mode, of course, has all the machinery in place to do this essentially automatically but Maiorana has some problems with it. He has multiple notebooks and finds it a pain to set up the ox-publish scaffolding for each one.

But this is Emacs so, of course, it’s easy to automate the process. Maiorana did that by writing a simple script, he calls OrgFolio, that

1. Deletes the existing Web content
2. Builds the scaffolding to export the Org files and exports them
3. Copies any static content, such as CSS files
4. Spins up a local Web server to show the content

All of this is kicked off from the command line with a call to Emacs in batch mode. It’s easy and has no overhead. It does require building everything from scratch,. which could be a problem for a large set of notes. That’s one of the reasons that Maiorana keeps a separate notebook for each topic.

I take copious notes about everything but they’re mainly for me so I see no need to export them to HTML. I’m perfectly happy to see them in plain text, just as I wrote them. That said, I do write them—complete with Org markup— as if they were going to be exported.

Still, if you take a lot of notes and would like to consume them as a Web page on your own private Web site, take a look at Maiorana’s post. His Elisp script is easy to read and modify if you want to adjust it for your own needs.

I want to love the Obsidian Long Form plugin, I even hoped it was a Scrivener replacement but it's failed me again and for the last time. Opening my project to write for the book club I found that it again forgot the order of all my files. I've reorganised them a number of times, but I'm not even bothering this time.

Emacs can be a full writing studio but I'm not abandoning Obsidian, I am going to take my monthly book club writing and move it into emacs.

Migrating .md to .org

First I need to migrate individual posts from Markdown to org files. Yes I know that Emacs has a markdown mode, but after a bit of research I decided to stick with org and let Emacs do it's thing. That means I need to migrate my existing writing into org using pandoc. I can do that with the script below.

pandoc -f markdown -t org input.md -o output.org

This gives me a file called output.org and converts my footnotes to an org compatible syntax. I can then copy the generated content into the new file for each book.

My plan is to keep each book in its own .org file and have each weekly post inside a subtree (heading). I can then export each subtree to markdown as needed for posting on my site.

Fixing Footnotes

My book club posts use footnotes heavily, so I needed them to survive the export back to Markdown intact. The built-in org markdown exporter (ox-md) does include footnotes, but with two problems.

First, the footnotes section gets a top-level # Footnotes heading regardless of where it sits in your document hierarchy. This means we have an h1 in the document which isn't what I want. Second, smart quotes and apostrophes get encoded as HTML entities — ’ instead of ', “ instead of ". Again, not what I want.

Both are fixable in the export function. The smart quotes issue is handled by passing :with-smart-quotes nil to the exporter. The heading level is fixed with a post-processing step that replaces # Footnotes with #### Footnotes before the output lands in the buffer.

(after! org
  (defun my/org-export-subtree-to-md ()
    (interactive)
    (let* ((md (org-export-as 'md t nil nil '(:with-toc nil :section-numbers nil :with-smart-quotes nil)))
           (md (replace-regexp-in-string "^# Footnotes$" "#### Footnotes" md)))
      (with-current-buffer (get-buffer-create "*Org MD Export*")
        (erase-buffer)
        (insert md)
        (goto-char (point-min))
        (pop-to-buffer (current-buffer)))))

  (map! :map org-mode-map
        :localleader
        "M" #'my/org-export-subtree-to-md))

The footnote links themselves render as HTML anchor tags (<sup><a href...>) rather than Markdown footnote syntax ([^1]). That's a limitation of ox-md, but it works fine in practice since most static site generators accept inline HTML.

Exporting to Markdown

Once the footnotes issues are sorted, the export workflow is straightforward. With my cursor inside the subtree I want to export, I press \ M and a *Org MD Export* buffer opens with the Markdown output ready to copy. The \ M binding assumes your Doom localleader is set to \ — if you haven't changed it, the default is , so it would be , M instead.

The t argument in org-export-as is what limits the export to the current subtree rather than the whole file. That matters because each book lives in one .org file with multiple subtrees — one per post. Without it, you'd get the entire book's worth of content every time.

I also suppress the table of contents and section numbers since those don't belong in a blog post:

'(:with-toc nil :section-numbers nil :with-smart-quotes nil)

Creating a project

Now to make it easier to access my 2026 book posts I need to create a project. First I needed to create a folder for them, I put it inside my Obsidian vault so that it syncs to all my devices.

To keep Obsidian syncing .org files you need to go to your sync settings and choose to sync "All Other Types" so that they get caught by Obsidian's sync process

While I got the project working, every time I've tried to get a new project in Emacs it takes far more tries than I expect.

First to be viewed as a project you need a .projectile file in the folder in question¹. So I typed SPC f f then went to ~/Documents/main/emacs-writing/2026-book-posts/.projectile and pressed Return. This tells me the file doesn't exist and we create it.

Next press SPC p a to add a project. Go to the same folder and press Return. Now you should be able to press SPC p p when you start Emacs and you'll see a list of your projects which you can select.

Sounds easy, but I think I restarted Emacs 3 times testing this before it worked as it should. Likely a user error.

Future Stuff?

This workflow is pretty new, as in this week, so there are a few things I'd like to explore. There is an Obsidian plugin for .org files that I'd like to try out. There is also obsidian.el which brings Obsidian features into Emacs.

I realise I'm giving up on backlinks in my writing doing things the way I am currently, but Long Form isn't working and I don't want to spend time moving files around when I have time to write.

I just want to write.

I'm having fun exploring which things might actually be easier to do by voice than by typing. For example, after I wrote some code to expand yasnippets by voice, I realized that it was easier to:

1. press my shortcut,
2. say "okay, define interactive function",
3. and then press my shortcut again,

than to:

1. mentally say it,
2. get the first initials,
3. type in "dfi",
4. and press Tab to expand.

Another area where I do this kind of mental translation for keyboard shortcuts is when I categorize dozens of Emacs-related links each week for Emacs News. I used to do this by hand. Then I wrote a function to try to guess the category based on regular expressions (my-emacs-news-guess-category in emacs-news/index.org, which is large). Then I set up a menu that lets me press numbers corresponding to the most frequent categories and use tab completion for the rest. 1 is Emacs Lisp, 2 is Emacs development, 3 is Emacs configuration, 4 is appearance, 5 is navigation, and so on. It's not very efficient, but some of it has at least gotten into muscle memory, which is also part of why it's hard to change the mapping. I don't come across that many links for Emacs development or Spacemacs, and I could probably change them to something else, but… Anyway.

I wanted to see if I could categorize links by voice instead. I might not always be able to count on being able to type a lot, and it's always fun to experiment with other modes of input. Here's a demonstration showing how Emacs can automatically open the URLs, wait for voice input, and categorize the links using a reasonably close match. The *Messages* buffer displays the recognized output to help with debugging.

This is how it works:

1. It starts an ffmpeg recording process.
2. It starts Silero voice activity detection.
3. When it detects that speech has ended, it use curl to send the WAV to an OpenAI-compatible server (in my case, Speaches with the Systran/faster-whisper-base.en model) for transcription, along with a prompt to try to influence the recognition.
4. It compares the result with the candidates using string-distance for an approximate match. It calls the code to move the current item to the right category, creating the category if needed.

Since this doesn't always result in the right match, I added an Undo command. I also have a Delete command for removing the current item, Scroll Up and Scroll Down, and a way to quit.

(easy-menu-define words-menu global-map
  "Menu for word navigation commands."
  '("Words"
     ["Forward word" forward-word]
     ["Backward word" backward-word]))

(keymap-set-after my-menu "<drink>"
  '("Drink" . drink-command) 'eat)

(defun my-emacs-news-categorize-with-voice (&optional skip-browse)
  (interactive (list current-prefix-arg))
  (unless skip-browse
    (my-spookfox-browse))
  (speech-input-cancel-recording)
  (let ((default (if (fboundp 'my-emacs-news-guess-category) (my-emacs-news-guess-category))))
    (speech-input-from-list
     (if default
         (format "Category (%s): " default)
       "Category: ")
     '(("Org Mode" "Org" "Org Mode")
       "Other"
       "Emacs Lisp"
       "Coding"
       ("Emacs configuration" "Config" "Configuration")
       ("Appearance" "Appearance")
       ("Default" "Okay" "Default")
       "Community"
       "AI"
       "Writing"
       ("Reddit" "Read it" "Reddit")
       "Shells"
       "Navigation"
       "Fun"
       ("Dired" "Directory" "Dir ed")
       ("Mail, news, and chat" "News" "Mail" "Chat")
       "Multimedia"
       "Scroll down"
       "Scroll up"
       "Web"
       "Delete"
       "Skip"
       "Undo"
       ("Quit" "Quit" "Cancel" "All done"))
     (lambda (result text)
       (message "Recognized %s original %s" result text)
       (pcase result
         ("Undo"
          (undo)
          (my-emacs-news-categorize-with-voice t))
         ("Skip"
          (forward-line)
          (my-emacs-news-categorize-with-voice))
         ("Quit"
          (message "All done.")
          (speech-input-cancel-recording))
         ("Reddit"
          (my-emacs-news-replace-reddit-link)
          (my-emacs-news-categorize-with-voice t))
         ("Scroll down"
          (my-spookfox-scroll-down)
          (my-emacs-news-categorize-with-voice t))
         ("Scroll up"
          (my-spookfox-scroll-up)
          (my-emacs-news-categorize-with-voice t))
         ("Delete"
          (delete-line)
          (undo-boundary)
          (my-emacs-news-categorize-with-voice))
         ("Default"
          (my-org-move-current-item-to-category
           (concat default ":"))
          (undo-boundary)
          (my-emacs-news-categorize-with-voice))
         (_
          (my-org-move-current-item-to-category
           (concat result ":"))
          (undo-boundary)
          (my-emacs-news-categorize-with-voice))))
     t)))

(defun my-spookfox-scroll-down ()
  (interactive)
  (spookfox-js-injection-eval-in-active-tab "window.scrollBy(0, document.documentElement.clientHeight);" t))

(defun my-spookfox-scroll-up ()
  (interactive)
  (spookfox-js-injection-eval-in-active-tab "window.scrollBy(0, -document.documentElement.clientHeight);"))

(defun my-spookfox-background-tab (url &rest args)
  "Open URL as a background tab."
  (if spookfox--connected-clients
      (spookfox-tabs--request (cl-first spookfox--connected-clients) "OPEN_TAB" `(:url ,url))
    (browse-url url)))

(defun my-org-move-current-item-to-category (category)
    "Move current list item under CATEGORY earlier in the list.
  CATEGORY can be a string or a list of the form (text indent regexp).
  Point should be on the next line to process, even if a new category
  has been inserted."
    (interactive (list (completing-read "Category: " (my-org-get-list-categories))))
    (when category
      (let* ((col (current-column))
             (item (point-at-bol))
             (struct (org-list-struct))
             (category-text (if (stringp category) category (elt category 0)))
             (category-indent (if (stringp category) 2 (+ 2 (elt category 1))))
             (category-regexp (if (stringp category) category (elt category 2)))
             (end (elt (car (last struct)) 6))
             (pos (point))
             s)
        (setq s (org-remove-indentation (buffer-substring-no-properties item (org-list-get-item-end item struct))))
        (save-excursion
          (if (string= category-text "x")
              (org-list-send-item item 'delete struct)
            (goto-char (caar struct))
            (if (re-search-forward (concat "^ *- +" category-regexp) end t)
                (progn
                  ;; needs a patch to ol.el to check if stringp
                  (org-list-send-item item (point-at-bol) struct)
                  (org-move-item-down)
                  (org-indent-item))
              (goto-char end)
              (org-list-insert-item
               (point-at-bol)
               struct (org-list-prevs-alist struct))
              (let ((old-struct (copy-tree struct)))
                (org-list-set-ind (point-at-bol) struct 0)
                (org-list-struct-fix-bul struct (org-list-prevs-alist struct))
                (org-list-struct-apply-struct struct old-struct))
              (goto-char (point-at-eol))
              (insert category-text)
              (org-list-send-item item 'end struct)
              (org-indent-item)
              (org-indent-item))
            (recenter))))))

(defun my-org-guess-list-category (&optional categories)
  (interactive)
  (require 'cl-lib)
  (unless categories
    (setq categories
          (my-helm-org-list-categories-init-candidates)))
  (let* ((beg (line-beginning-position))
         (end (line-end-position))
         (string (buffer-substring-no-properties beg end))
         (found
          (cl-member string
                     categories
                     :test
                     (lambda (string cat-entry)
                       (unless (string= (car cat-entry) "x")
                         (string-match (regexp-quote (downcase (car cat-entry)))
                                       string))))))
    (when (car found)
      (my-org-move-current-item-to-category
       (cdr (car found)))
      t)))

You can comment on Mastodon or e-mail me at sacha@sachachua.com.

A few weeks ago, I wrote a post about “distributed notebooks” generated in Org Mode and published to bare bones Web 1.0 HTML pages. Now here’s the sequel: OrgFolio. For the diligent note-takers, lifelong learners, deep readers, seekers, philosophers, Junior Orwells, and obsessive Emacs users in all of us.

emacs --batch --load build.el

project/
├── build.el       ← the build script
├── org/           ← your .org source files go here
└── static/        ← CSS, JS, images, fonts

emacs --batch --load build.el

The post OrgFolio | Turn your scattered interests into cultivated obsessions appeared first on Chris Maiorana.

Eric MacAdie has a contribution to this month’s Emacs Carnival that talks about his major mistake in learning and using Emacs. That “mistake”, he says, was not embracing Emacs completely when he was introduced to it. Instead, he learned only a few commands—he estimates about a dozen—and limped along with those. He might as well have been using Notepad.

Fortunately MacAdie did finally fully embrace Emacs and started to learn as much as he could about what it had to offer. This wouldn’t have been much of a story except that I keep seeing people expressing the attitude that they’re too busy to learn Emacs. “Why doesn’t it just work out of the box?”, they ask.

The thing is, it does work out of the box. To be sure, your Emacs life will doubtless involve customizing it to fit your specific workflow but Emacs is perfectly usable without making a single change. The thing is, you have to be willing, as MacAdie was, to actually make the effort to learn Emacs in order to realize its full power.

Learning Emacs is not trivial but it’s also not that hard. Irreal has published plenty of stories detailing its advanced use by non-technical people, most recently here. If you want to advance beyond, say Notepad, put in the effort to learn Emacs. It will reward you far in excess of your effort.

Might be a good opportunity to set up better auto-saves, with buffer-guardian.el inspiring an update to super-save 0.5. Also, there were a couple of interesting experiments embedding Chromium (Reddit) or native macOS views in Emacs (Reddit), and one about embedding Emacs in a webpage (Reddit).

• Upcoming events (iCal file, Org):
  • Emacs Berlin: Emacs-Berlin Hybrid Meetup https://emacs-berlin.org/ Wed Mar 25 1100 America/Vancouver - 1300 America/Chicago - 1400 America/Toronto - 1800 Etc/GMT - 1900 Europe/Berlin - 2330 Asia/Kolkata – Thu Mar 26 0200 Asia/Singapore
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Mar 28 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 0930 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/313720093/ Thu Apr 2 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Fri Apr 3 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Apr 3 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
• Emacs configuration:
  • decoupling C-m (aka RET) and <return>
• Emacs Lisp:
  • elisp-2025/el-xeger.el (Reddit)- generate text from a regex
  • [20] Working on Canvas Patch (Contd..) - 3/22/2026, 2:31:11 PM - Dyne.org TV
• Writing:
  • miljko/microbe.el: A high-performance, offline-first Emacs manager for Micro.blog · GitHub
  • blogmore.el v1.7 - davep (also 1.4 update, other post)
• Appearance:
  • Chris Maiorana: Writing gloriously long sentences in Emacs with line highlighting (Irreal)
    • Tip about setting hl-line-range-function to identify current line in visual line mode
  • Protesilaos Stavrou: Emacs: doric-themes version 1.1.0
• Navigation:
  • repo-grep.el – update
• Dired:
  • Emacs - Rename currently opened file in Dired mode (03:21)
• Org Mode:
  • Which org-related packages do you use?
  • Taking Notes With Emacs Org Mode (It's Easy!) (15:35)
  • Reading your Emacs notes on-the-go, minimally. (12:07, (Reddit)
  • Srijan Choudhary: 2026-03-18-001: move Org heading title into body
  • Resilient Technologies. Why Decades-Old Tools Define the ROOT of Modern Research Data Management — Workshop Documents (@lukascbossert@mastodon.social)
• Coding:
  • aspiers/madolt: magit-like emacs mode for dolt · GitHub (Reddit)
  • Emacs VC-mode in action (01:34)
  • Projeto Omega - Cifra de Cesar (Emacs+Magit) (14:39)
  • Lycomedes1814/temme-mode: A rewrite of emmet-mode for Emacs, aiming for a clean and modern codebase · GitHub (Reddit)
  • Emacs Redux: surround.el: Vim-Style Pair Editing Comes to Emacs (Irreal)
  • Emacs Redux: Tree-sitter Font-Lock and Indentation in Comint Buffers
  • Tip about using python-indent-def-block-scale - mutliplier applied to indentation
  • Einar Mostad: Use virtual environment in Emacs' Python Mode if in a project with a venv
  • Monday Live Coding with Emacs. 3/16/2026 #coding #livecoding #emacs #learnc (01:16:08)
• Mail, news, and chat:
  • newsflash.el I built a lightweight RSS news reader for Emacs with split-screen reading (Reddit)
• Multimedia:
  • emacs-os/elcava: Cava clone in emacs lisp · GitHub (Reddit) Audio spectrum visualizer
  • jellyfin-emms-mpv.el - Browse and play music/video from a Jellyfin server via EMMS + mpv (Reddit)
• Fun:
  • emacs is really good for ascii-art (Reddit)
  • Run Emacs in your browser with v86 (Reddit)
  • zenitsu7772000/manga-reader - Manga & Comic Reader for Emacs (Reddit)
• AI:
  • Agile & Coding: The tools of an Agentic Engineer (Reddit)
  • jlouisbiz/rcd-mcp-emacs-documentation: get_documentation, list_functions_by_prefix, search_functions, rcd_elisp_function_definition
  • MCP for Emacs - Improve your notes with ORG MODE 🦄 (10:27)
  • agent-shell-notifications released! (Reddit)
  • Jeremias-A-Queiroz/emacs-gptel-slim-tools: leverage etags for precise code fragment extraction (Reddit)
  • Fritz Grabo: acp2ollama in Emacs for fun and profit
  • James Dyer: Ollama Buddy - Seven Lines to Any LLM Provider
• Community:
  • I tried Neovim, but I keep coming back to Emacs
  • Eric MacAdie: Emacs Carnival: Mistakes and Misconceptions
• Shells:
  • Making Emacs output true 24-bit color in the terminal: a two-line terminfo fix
• Other:
  • buffer-terminator.el - safely auto terminate buffers for performance and reduced clutter [Release 1.2.1]​ (Reddit)
  • James Cherti: buffer-guardian.el – Automatically Save Emacs Buffers Without Manual Intervention (When Buffers Lose Focus, Regularly, or After Emacs is Idle) (Reddit, Irreal)
  • super-save 0.5: Modernized and Better Than Ever (Reddit)
  • Much Ado About Emacs 012: kirigami, visible-mark, javelin, opml, appine, buffer-guardian, isearch-lazy-count, markdown-table-wrap, surround
  • chaoswork/appine: embed native macOS views (WebKit, PDFKit etc.) directly inside Emacs windows. · GitHub (Reddit)
  • emacs-os/embr.el: Emacs is the display server. Headless Chromium via CloakBrowser is the renderer. · GitHub (Reddit)
  • Why fork+exec Takes 100ms on My Mac: Debugging Slow Emacs with Instruments (Reddit)
  • exlee/emacs-reporter: Emacs data collector for macOS · GitHub (Reddit)
• Emacs development:
  • emacs-devel:
    • Re: MacOS/NS Events Processing Queue - Przemysław Kamiński - VM compacting patch in case anyone wants to try it out
    • Re: Tree-sitter: Correctly parsing template-like embeddings - Yuan Fu - trade-offs for performance?
    • Re: feature/igc3 44f854bad09 2/5: Avoid remote references in face cache (analogous to bug#80601) - Eli Zaretskii - challenges with igc branch
    • Re: some Eglot-related options to consider for newcomers-presets - João Távora - language servers and newcomers-presets?
  • (Fmakunbound): Break aliasing, if present (bug#80538)
  • hideshow: Fix 'hs-hide-block-behavior' set to 'after-cursor'.
  • hideshow: New minor mode 'hs-indentation-mode'. (Bug#80179)
• New packages:
  • async-http-queue: Async HTTP queue with parallel fetching (MELPA)
  • consult-symbol: Consult-based symbol search with narrowing (MELPA)
  • flymake-zizmor: Flymake backend for zizmor, a Github Actions static analyzer (MELPA)
  • org-snitch: Project-specific org-capture and link faces (MELPA)
  • org-tag-cloud: Easily maintain a tag-cloud of org-mode tags (MELPA)
  • tiles: Tagged Instant Lightweight Emacs Snippets (MELPA)

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

You can comment on Mastodon or e-mail me at sacha@sachachua.com.

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

[ The stream will be recorded. You can watch it later. ]

I do not have any work this evening, so I will do a live stream. My plan is to do some programming. I have a new idea for the denote-sequence package that I will try to implement.

If there are any questions from the chat, I will answer them. They can be about what I will be working on or any other topic.

Talk to you soon!

These are my minimalist themes. They use few colours and will appear mostly monochromatic in many contexts. Styles involve the careful use of typography, such as italics and bold italics.

If you want maximalist themes in terms of colour, check my ef-themes package. For something in-between, which I would consider the best “default theme” for a text editor, opt for my modus-themes.

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

Below are the release notes.

Version 1.1.0 on 2026-03-23

This version introduces minor refinements to the underlying code as well as four new themes.

The new themes are as follows:

• doric-almond: A light theme that combines green and magenta colours. It evokes a feeling of early springtime, as the almond tree is among the first to bloom.

• doric-coral: A light theme with a warmer feel that combines red, orange, and cyan colours against a sandy backdrop.

• doric-magma: A dark theme with a dominant red and orange style. The combination of those intense hues with lighter greys creates the necessary balance.

• doric-walnut: A dark theme with an overall green style, drawing inspiration from the broad leaves of the walnut tree. The green colours are combined with shades of brown and grey to make for a pleasant presentation.

Enjoy!

A couple of years ago, I wrote about Chris Maiorana’a post suggesting that writers adopt a one-line-per-sentence workflow. You can read his post on the matter to see his arguments on why. At the time, I wrote that I used that method for my two books but because it worked better with the [GT]roff typesetter rather than for any writer workflow reasons. Since moving to Org mode for my writing I’ve given it up not least because it doesn’t play well with WordPress where a lot of my writing ends up.

Maiorana is back with another post on the subject that those who embrace the method may find useful. His idea is to use Emacs’ hl-line-mode to highlight the current line. That brings some other benefits to the one-line-per-sentence method that Maiorana describes in his latest post.

I used to use hl-line-mode, although not in conjunction with one-line-per-sentence, but stopped because it interacted poorly with some other mode—probably visual-line-mode where it highlights whole paragraphs. Even when I was using it, I sometimes found it annoying despite it being useful for locating the current line. I’m sure I’m in the minority on that so you should definitely give it a try if you’re not familiar with it. It’s builtin so you can simply toggle it on for the current buffer with Meta+x hl-line-mode to try it out.

A couple of months ago, I wrote about friction in saving files. Emacs, of course, tries to protect you from unsaved buffers by periodically backing them up to a special file. Recovering data from that file can be a bit finicky and since Emacs and modern computers don’t crash very often, you don’t get a lot of practice.

A long time ago, Bozhidar Batsov solved that problem with super-save that saved buffers whenever the buffer loses focus or perhaps every few seconds. It’s all configurable, of course. In the mean time, James Cherti wrote buffer-guardian.el that does pretty much the same thing.

Cherti’s solution took advantage of more recent Emacs features to provide a more reliable solution. When Batsov “stumbled upon buffer-guardian.el” he decided to revisit super-saver, which he hadn’t touched since 2023. He’s improved the detection of buffer focus change no matter how it’s invoked. There are a several other improvements that you can read about in Batsov’s post.

I’m inclined not to like my software doing things automatically that I’m used to asking for explicitly so neither buffer-guardian nor super-saver appeal to me but I’m probably in the minority on this so many of you probably will like using one of these packages. As I say, I don’t use either one so I can’t comment on their relative merits but they both seem like useful and worthy packages.

If you’re bad about saving your files and worry that you may lose work, you should take a look at these packages. One or both of them may be just what you need.

Emacs

Haven’t written an update on my usage of Emacs for a while. Decided to stop tweaking the configuration to concentrate on getting familiar with what I have setup. That lasted for two seconds. Emacs developers are coming up with new things and I have severe FOMO. I have additions.

Kirigami

Kirigami “The kirigami Emacs package provides a unified method to fold and unfold text in Emacs across a diverse set of Emacs modes.” One set of keybindings to open/close folds across a wide range of modes, including markdown-mode, outline-mode and org-mode.

This is my general.el setup for kirigami

 ;; kirigami
  "k" '(nil :which-key "kirigami")
  "kc" '(kirigami-close-folds :which-key "close all")
  "ko" '(kirigami-open-folds :which-key "open all")
  "kp" '(kirigami-open-fold :which-key "open at point")
  "kr" '(kirigami-open-fold-rec :which-key "open rec")
  "kt" '(kirigami-toggle-fold :which-key "toggle folds")

Visible Marks

visible-mark - MELPA and ideasman42/emacs-visible-mark - Codeberg.org Minor mode to highlight mark(s). Allows setting the number of marks to display, and the faces to display them.

These are my settings for visual-mark

(defface visible-mark-active
  '((((type tty) (class mono)))
    (t (:background "magenta"))) "")
(setq visible-mark-max 2)
(setq visible-mark-faces `(visible-mark-face1 visible-mark-face2))
(use-package visible-mark
  :ensure t)
(global-visible-mark-mode 1)

Javelin

DamianB-BitFlipper/javelin.el at 9516e3729b8cd85d6b02fd1940ec10638c6706cb

Described by the author as “Quick file bookmarks for Emacs, inspired by ThePrimeagen’s Harpoon. Pin files to numbered positions (1-9) for instant access. Positions are automatically separated by project and git branch.”

I like it. The only problem is that the list doesn’t last across restarts of Emacs. Have to figure out how to achieve that.

OPML to Org-mode

I bought OmniOutliner 6 Pro. That produces OPML files. I wanted to be able to convert them to Org-mode. Gemini helped.

;; Converting OPML to Org-mode

(defun my/opml-to-org-with-notes (opml-file)
  "Convert an OPML file's 'outline' elements and their notes into Org-mode."
  (interactive "fSelect OPML file: ")
  (let* ((xml (xml-parse-file opml-file))
         ;; Standard OPML structure is <opml><body>...</body></opml>
         (body (car (xml-get-children (car xml) 'body)))
         (outlines (xml-get-children body 'outline))
         (new-buf (generate-new-buffer "*OPML Import with Notes*")))
    (with-current-buffer new-buf
      (org-mode)
      (cl-labels ((parse-outline (nodes level)
                    (dolist (node nodes)
                      (let* ((attrs (xml-node-attributes node))
                             (text (cdr (assoc 'text attrs)))
                             (note (or (cdr (assoc '_note attrs)) 
                                       (cdr (assoc 'description attrs))))
                             (children (xml-get-children node 'outline)))
                        ;; Create Heading
                        (insert (make-string level ?*) " " (or text "Untitled") "\n")
                        ;; Insert Note (if it exists)
                        (when note
                          (insert note "\n"))
                        ;; Recurse for nested nodes
                        (when children
                          (parse-outline children (1+ level)))))))
        (parse-outline outlines 1))
      (goto-char (point-min)))
    (switch-to-buffer new-buf)))

Appine

chaoswork/appine: Appine

“Appine means”App in Emacs”, which is an Emacs plugin using a Dynamic Module that allows you to embed native macOS views (WebKit, PDFKit, Quick look PreviewView, etc.) directly inside Emacs windows.”

This is my Appine setup:

;; appine
(use-package appine
  :straight (appine :type git :host github :repo "chaoswork/appine")
  :custom
  ;; enables opening URLs and files with Appine, default is nil
  (appine-enable-open-in-org-mode nil) 
  :config
  ;; Optional: Set default keybindings
  (global-set-key (kbd "C-x a w") 'appine-open-web-split)
  (global-set-key (kbd "C-x a o") 'appine-open-file-split))

Turned off (appine-enable-open-in-org-mode nil). I don’t want links to be opened in org-mode without me specifically wanting it. When the link opens in Emacs, I don’t have the ability to zoom in/out. I am old, I need that for most sites.

My general.el setup for Appine.

  ;; Windows
  "w" '(nil :which-key "window")
  "ww" '(appine-open-web-split :which-key "appine-web")
  "wf" '(appine-open-file-split :which-key "appine-file")

buffer-guardian

buffer-guardian.el – Automatically Save Emacs Buffers Without Manual Intervention (When Buffers Lose Focus, Regularly, or After Emacs is Idle) | James Cherti

Saves you from having to continuously save your document. It automatically saves when the buffer loses focus.

There is an alternative to this package, super-save 0.5: Modernized and Better Than Ever | Emacs Redux.

My setup for buffer-guardian is:

(use-package buffer-guardian
  :custom
  ;; When non-nil, include remote files in the auto-save process
  (buffer-guardian-inhibit-saving-remote-files nil)

  ;; When non-nil, buffers visiting nonexistent files are not saved
  (buffer-guardian-inhibit-saving-nonexistent-files t)

  ;; Save the buffer even if the window change results in the same buffer
  (buffer-guardian-save-on-same-buffer-window-change t)

  ;; Non-nil to enable verbose mode to log when a buffer is automatically saved
  (buffer-guardian-verbose nil)

  ;; Save all buffers after N seconds of user idle time. (Disabled by default)
  ;; (buffer-guardian-save-all-buffers-idle 30)

  :hook
  (after-init . buffer-guardian-mode))

isearch-lazy-count

isearch-lazy-count: Built-in Search Match Counting | Emacs Redux

This is useful. My setup:

#+begin_src emacs-lisp
;;customizing isearch
(setopt isearch-lazy-count t)
(setopt lazy-count-prefix-format nil)
(setopt lazy-count-suffix-format " [%s/%s]")
#+end_src

markdown-table-wrap

dnouri/markdown-table-wrap at 71a1cec53bf9d7875126b4cd557b2c00ae52b576

Markdown tables wrapped to a defined character width.

My setup:

#+begin_src emacs-lisp
;; markdown-table-wrap
(use-package markdown-table-wrap
  :ensure t
  :config
  (markdown-table-wrap table-text 60))
#+end_src

surround.el

surround.el: Vim-Style Pair Editing Comes to Emacs | Emacs Redux

Useful package to delete paired delimiters.

My setup:

#+begin_src emacs-lisp
(use-package surround
  :ensure t
  :bind-keymap ("M-'" . surround-keymap))
#+end_src

Conclusion

Using Emacs every day. My comfort with the program is increasing. I am learning and I am having a blast. That is all I have for now.

macosxguru

Cupcakes

Poetry (non-Emacs related)

Ever found yourself wanting to add a new AI provider to ollama-buddy? (probably not I would guess 🙂), only to realise you’d need to write an entire Elisp module? Or perhaps you’re running a local inference server that speaks the OpenAI API, but can’t be bothered with the ceremony of creating a dedicated provider file?

Fair question. That’s exactly why I built ollama-buddy-provider-create — a single function that lets you register any LLM provider in seconds, whether it’s a cloud API or your own local server.

The traditional approach required a separate .el file for each provider — OpenAI, Claude, Gemini, you name it. Each with its own defcustom variables, configuration boilerplate, and maintenance overhead. It worked, but it felt a bit… heavy-handed for simple use cases.

What if you just wanted to quickly add support for that new local LM Studio instance running on port 1234? Or point ollama-buddy at your company’s internal AI gateway? Previously, you’d be looking at copying an existing provider file and modifying dozens of lines. Now? One function call.

The magic (yes, of the elisp kind!) happens in ollama-buddy-provider.el, which provides a generic provider registration system. Instead of requiring separate Elisp files, you can register any provider with a single call:

(ollama-buddy-provider-create
 :name "My Local Server"
 :api-type 'openai
 :endpoint "http://localhost:1234/v1/chat"
 :models-endpoint "http://localhost:1234/v1/models"
 :api-key "your-key-here"
 :prefix "l:")

Three API types are supported out of the box:

• openai (default) — Any OpenAI-compatible chat/completions API
• claude — Anthropic Claude Messages API
• gemini — Google Gemini generateContent API

The system handles all the underlying HTTP requests, error mapping, and session management automatically. Your provider just needs to specify which API flavour it speaks.

Adding a local LM Studio instance:

(ollama-buddy-provider-create
 :name "LM Studio"
 :api-type 'openai
 :endpoint "http://localhost:1234/v1/chat/completions"
 :models-endpoint "http://localhost:1234/v1/models"
 :api-key "not-needed" ; LM Studio often doesn't require auth
 :model-prefix "l:")

Connecting to OpenRouter (400+ models through one API):

(ollama-buddy-provider-create
 :name "OpenRouter"
 :api-type 'openai
 :endpoint "https://openrouter.ai/api/v1/chat/completions"
 :models-endpoint "https://openrouter.ai/api/v1/models"
 :api-key "your-openrouter-key"
 :model-prefix "r:")

After registration, your new provider appears in the status line and becomes available through the standard model selection interface. The model-prefix (like l: for local or r: for OpenRouter) lets you quickly identify which provider a model belongs to.

The provider system leverages ollama-buddy’s shared infrastructure in ollama-buddy-remote.el, which extracts common functionality like request handling, error mapping, and response processing. This means your custom provider gets the same robust error handling as the built-in ones:

• Proper HTTP status code mapping (rate limits, timeouts, authentication errors)
• Async request support for non-blocking UI
• Automatic model listing and caching
• Integration with the existing session and conversation system

When you call ollama-buddy-provider-create, it registers your provider with the core system, making it available to all the usual entry points: the transient menu, model selection, and conversation buffers.

This approach is perfect for:

• Local inference servers (LM Studio, llama.cpp, vLLM, Ollama’s own OpenAI-compat layer)
• Company/internal AI gateways
• Quick experiments with new APIs

The beauty ojf this system is that it makes ollama-buddy genuinely extensible without requiring deep knowledge of its internals. Want to add support for that new AI service that launched yesterday? You can probably do it in five lines of configuration rather than fifty.

Next up I think this will be the big one, adding tooling for those external providers!!!

That didn’t take long. After yesterday’s post on adapting Bozhidar Batsov’s delete-surrounding-pair function to handle Org markup, Batsov is back with a post on surround.el, a port of surround.vim from Michael Kleehammer. The point of delete-surrounding-pair was to (sort of) emulate Vim’s surround plugin. Now with support.el, there’s no longer a need for delete-surrounding-pair.

Surround does everything delete-surrounding-pair did and a lot more. You can delete surrounding pairs, add pairs, change pairs, mark or kill the content between the pairs, or even kill the text and the surrounding pair. It really is a splendid package and I’ve already added it to my configuration and deleted my adaption of delete-surrounding-pair.

Surround will check if the pair you’re operating on has different opening and closing characters and do the right thing automatically. The other nice thing is that there aren’t a lot of key sequences to remember. Once you pick a prefix that you’ll remember the (single) action keys are mnemonic and easy to remember. In any event, which-key pops up a reminder.

I installed it with the recommended prefix of Meta+’ but keep wanting to invoke it with Hyper+’ so I’ll probably change it but, regardless, I’m already enjoying using it.

Take a look at Batsov’s post or the Github repository for all the details. Batsov’s post has some recommendations on when you should use it and Kleehammer’s repository has information on shortcuts and auto mode, which you should read. This is a really useful package and I recommend that everyone take a look at it.

A hands-on look at using acp2ollama to connect ACP agents to Emacs packages that speak the Ollama API — with results ranging from 'works great' to 'probably don't bother.'

The other day I wrote about Bozhidar Batsov’s post on deleting paired delimiters in Emacs and mentioned that he included a bit of Elisp that—sort of—duplicated the behavior of Vim’s surround.vim. The idea is that if you are in a delimited expression and invoke the function, it will ask what delimiter you want to delete and will delete the closest enclosing pair. That obviously has some shortcomings such as not recognizing if one of the delimiters is in, say, a string. Still it’s handy code that does the right thing in most cases.

The code was interesting but I thought I didn’t need it because delete-pair already handled all the cases I was concerned with. As I was writing about Batsov’s post, I had something like =some text= and realized that I didn’t want it displayed in monospace after all. Since delete-pair was on my mind, I tried it but of course it didn’t work because = isn’t a delimiter that delete-pair recognizes so I deleted them by hand.

Later, I realized that I could simply add the Org markup pairs I was interested in to Batsov’s code so I did that and added it to my init.el. It worked perfectly and now I have an easy way of deleting Org markup .

It’s worth noting that Org mode gives you a way to do the opposite too: if you highlight some text and call org-empasize (Ctrl+c Ctrl+x Ctrl+f) it will add the Org markup you choose to the highlighted text.

Note

After I wrote this post, I found out about surround.el. More about that tomorrow.

A small #Emacs #OrgMode quality-of-life tweak. I often need to replace an org heading's title while preserving the original text in the body. The problem is that pressing enter on a heading inserts a line above the properties drawer, which breaks things.

Here's a function that moves the heading title into the body (below the properties drawer and metadata), and binds it to S-RET:

(defun my-org-demote-title-to-body ()
  "Move the current heading's title into the body, below the metadata.
  Point returns to the heading for editing."
  (interactive)
  (org-back-to-heading t)
  (let* ((element (org-element-at-point))
         (title (org-element-property :raw-value element)))
    (org-edit-headline "")
    (save-excursion
      (org-end-of-meta-data t)
      (insert title "\n"))
    (org-beginning-of-line)))

(defun my-org-shift-return ()
  "On a heading, demote title to body. In a table, copy down."
  (interactive)
  (cond
   ((org-at-heading-p) (my-org-demote-title-to-body))
   ((org-at-table-p) (org-table-copy-down 1))
   (t (org-return))))
  (define-key org-mode-map (kbd "S-<return>") #'my-org-shift-return)

It’s been a while since the last super-save release. The last time I wrote about it was back in 2018, when I boldly proclaimed:

It seems that now super-save is beyond perfect, so don’t expect the next release any time soon!

Famous last words. There was a 0.4 release in 2023 (adding a predicate system, buffer exclusions, silent saving, and trailing whitespace cleanup), but I never got around to writing about it. The package has been rock solid for years and I just didn’t pay it much attention – it quietly did its job, which is kind of the whole point of an auto-save package.

A Bit of History

The idea behind super-save goes all the way back to a blog post I wrote in 2012 about auto-saving buffers on buffer and window switches. I had been using IntelliJ IDEA for Java development and loved that it would save your files automatically whenever the editor lost focus. No manual C-x C-s, no thinking about it. I wanted the same behavior in Emacs.

Back then, the implementation was crude – defadvice on switch-to-buffer, other-window, and the windmove commands. That code lived in Emacs Prelude for a few years before I extracted it into a standalone package in 2015. super-save was born.

What Prompted This Release

Yesterday I stumbled upon buffer-guardian.el, a package with very similar goals to super-save. Its README has a comparison with super-save that highlighted some valid points – mainly that super-save was still relying on advising specific commands for buffer-switch detection, while newer Emacs hooks like window-buffer-change-functions and window-selection-change-functions could do the job more reliably.

The thing is, those hooks didn’t exist when super-save was created, and I didn’t rush to adopt them while Emacs 27 was still new and I wanted to support older Emacsen. But it’s 2026 now – Emacs 27.1 is ancient history. Time to modernize!

What’s New in 0.5

This is the biggest super-save release in years! Here are the highlights:

Modern buffer/window switch detection

Buffer and window switches are now detected via window-buffer-change-functions and window-selection-change-functions, controlled by the new super-save-when-buffer-switched option (enabled by default). This catches all buffer switches – keyboard commands, mouse clicks, custom functions – unlike the old approach of advising individual (yet central) commands.

Modern focus handling

Frame focus loss is now detected via after-focus-change-function instead of the obsolete focus-out-hook, controlled by super-save-when-focus-lost (also enabled by default).

Soft-deprecated trigger system

With the new hooks in place, both super-save-triggers and super-save-hook-triggers now default to nil. You can still use them for edge cases, but for the vast majority of users, the built-in hooks cover everything.

org-src and edit-indirect support

super-save now knows how to save org-src edit buffers (via org-edit-src-save) and edit-indirect buffers (via edit-indirect--commit). Both are enabled by default and controlled by super-save-handle-org-src and super-save-handle-edit-indirect.

Safer predicates

Two new default predicates prevent data loss: verify-visited-file-modtime avoids overwriting files modified outside Emacs, and a directory existence check prevents errors when a file’s parent directory has been removed. Predicate evaluation is also wrapped in condition-case now, so a broken custom predicate logs a warning instead of silently disabling all auto-saving.

Emacs 27.1 required

This allowed cleaning up the code and relying on modern APIs.

Upgrading

For most users, upgrading is seamless – the new defaults just work. If you had a custom super-save-triggers list for buffer-switching commands, you can probably remove it entirely:

;; Before: manually listing every command that switches buffers
(setq super-save-triggers
      '(switch-to-buffer other-window windmove-up windmove-down
        windmove-left windmove-right next-buffer previous-buffer))

;; After: the window-system hooks catch all of these automatically
;; Just delete the above and use the defaults!

If you need to add triggers for commands that don’t involve a buffer switch (like ace-window), super-save-triggers is still available for that.

A clean 0.5 setup looks something like this:

(use-package super-save
  :ensure t
  :config
  ;; Save buffers automatically when Emacs is idle
  (setq super-save-auto-save-when-idle t)
  ;; Don't display "Wrote file..." messages in the echo area
  (setq super-save-silent t)
  ;; Disable the built-in auto-save (backup files) since super-save handles it
  (setq auto-save-default nil)
  (super-save-mode +1))

It’s also worth noting that Emacs 26.1 introduced auto-save-visited-mode, which saves file-visiting buffers to their actual files after an idle delay. This overlaps with super-save-auto-save-when-idle, so if you prefer using the built-in for idle saves, you can combine the two:

(use-package super-save
  :ensure t
  :config
  ;; Don't display "Wrote file..." messages in the echo area
  (setq super-save-silent t)
  ;; Disable the built-in auto-save (backup files)
  (setq auto-save-default nil)
  (super-save-mode +1))

;; Let the built-in auto-save-visited-mode handle idle saves
(auto-save-visited-mode +1)

Burst-Driven Development Strikes Again

Most of my Emacs packages are a fine example of what I like to call burst-driven development – long periods of stability punctuated by short intense bursts of activity. I hadn’t touched super-save in years, then spent a few hours modernizing the internals, adding a test suite, improving the documentation, and cutting a release. It was fun to revisit the package after all this time and bring it up to 2026 standards.

If you’ve been using super-save, update to 0.5 and enjoy the improvements. If you haven’t tried it yet – give it a shot. Your poor fingers might thanks for you this, as pressing C-x C-s non-stop is hard work!

That’s all I have for you today. Keep hacking!

Everyone knows I love finding whatever Emacs tricks and dodges I can to help writers. I wrote an article a while back about the benefits of writing in one-sentence-per-line (OSPL) style. No need to re-hash the whole article, but suffice to say this style can help you organize and transpose sentences, get a quick visual cue for sentence length and complexity, as well as clearer version control diffs, etc.

Transitioning over to this style from the standard paragraph-per-line style can be a little disorienting at first, especially if your longer soft-wrapped sentences are starting to ramble into two or three lines. This where hl-line-mode in Emacs can be a big help. Most text editors have a highlighting feature to help you focus on the current working line, and Emacs is no different. In this article, we’ll take a look at the built-in highlighting mode in Emacs and all the hows and whys you need to know.

Before we get into it, I will mention that if you are a power writer, and want to join the elite of Emacs users, you should check out my downloadable DRM-free eBooks here:

• Emacs For Writers
• Git For Writers

Let’s dig into hl-line-mode now.

(global-hl-line-mode 1)

M-x global-hl-line-mode

The post Writing gloriously long sentences in Emacs with line highlighting appeared first on Chris Maiorana.

Today, I was going to work on a python project for half an hour at the end of my work day. I tried to find a good python module to use to work with RSS and Atom feeds. I found one and installed it in my virtual environment and pasted in some example code in a buffer in Emacs. I wanted to run the code in the python shell with Emacs' handy C-c C-c keyboard shortcut. So I opened the shell with C-c C-p and then hit C-c C-c, but I got an error that the shell did not understand the import on line 1 where I was importing the module I just installed in my virtualenv. I realised the shell ran from outside the virtualenv. I had not looked into this before, but found there were various packages people recommended to fix this. I tried one that looked interesting, but it did not work. Maybe because I was on my work laptop with Windows at the time. I tried a few things, but soon gave up.

I then discovered .dir-locals.el was a possible solution. It gives buffer-local values to variables inside the folder it is placed for the mode that you configure through an alist. The first suggestion I found was to use a variable that did not work at all. I wasted a lot of time trying to get it to work. When I was close to giving up, I discovered that I could use the usual python-shell-interpreter variable in the .dir-locals.el file and it worked. I then thought that the solution I had found would not work on my own machines that run GNU/Linux since the python.exe-file neither exists nor the folder it is in in virtual environments on my preferred platform. A .dir-locals.el-file checked in with git is not a particularly cross-platform solution. I thought I could make a function in my config that would check which platform I was on, whether I was in a project or not and whether a directory with the name venv exists (I tend to use that name) and then just set the variable to the correct path based on that.

When I got home, after dinner, I made that function. I love how well-documented Emacs is. It makes doing things like this really easy. I just looked up function names starting with project and found something useful after reading up on a few. A bit of evaluation in different buffers with C-x C-e to check if things worked the way I thought and a bit of tweaking when it turned out that cddr did not return the same as nth 2 (cddr returned a list with a string, but nth 2 returned a string) and then I ended up with this function:

(defun emo-python-virtualenv ()
  "Sets the python interpreter to python in the venv if in a project and a venv exists."
  (when (project-current)
    (let ((pythonpath (concat
                       (nth 2 (project-current)) (if (eq system-type 'gnu/linux)
                                                     "venv/bin/python"
                                                   "venv/Scripts/python.exe"))))
      (when (file-exists-p pythonpath)
        (setq-local python-shell-interpreter pythonpath)))))

To put it to work every time I open a python file, I also needed to add it to python-mode-hook like this in my configuration for Python mode:

(add-hook 'python-mode-hook 'emo-python-virtualenv)

When I now try to import packages that only exists in a venv into the python shell, it works if I loaded the shell from a file within the same project as the venv with the package, but not from a file from outside that project. If I load the shell from a file within a project without a venv, I get the system's Python and its available packages. No need for outdated packages that doesn't work or directory-local variables that are platform dependent. This should work on Windows as well. (I haven't tested it yet, but I will tomorrow.) It's easy and fun to fix things like this in Emacs, and I learned some Elisp and a bit about Python virtual environments in the process. It would be convenient if things like these worked out of the box, but that would demand a bit more code since my function works on the basis of me using the name venv for every venv which other people might not.

A recurrent theme here at Irreal is that Emacs is for everyone, not just programmers. Every time I find an example of this I try to write about it. It’s a point that Protesilaos Stavrou made in his recent FOSS @ Oxford talk.

Now, in a lovely piece of serendipity, we have Randy Ridenour providing a real world example. Ridenour is a Philosophy professor and, as he himself says, is by no means a programmer. Still, as Prot suggested, he has learned enough to automate some of his Emacs tasks. He started by copying other people’s code but tried to understand what it did.

Now he needs to convert quiz questions from one format to another for the learning management system that his university uses—see his post for the details. This amounts to running a series of regular expression replacements, which he did by hand for a while. Then he realized—as I always find myself doing—that he could just write a bit of Elisp to automate the process.

Ridenour isn’t a programmer and he isn’t a young turk who grew up with all this technology. He’s old enough to have a married daughter so while he may or may not qualify for the Irreal Geezer Club, he is obviously well along in his career. And yet he finds it easy to learn enough Elisp to reduce the friction in his workflow. His colleagues are probably still grumbling about how hard it is to deal with the quizzes but he’s turned all those problems over to Emacs.

If you maintain a tree-sitter major mode that has a REPL (comint) companion, you’ve probably wondered: can the REPL input get the same syntax highlighting and indentation as source buffers? The answer is yes – and the infrastructure has been in Emacs since 29.1. It’s just not widely known yet.

I ran into this while working on neocaml, my tree-sitter major mode for OCaml. The OCaml REPL buffer used simple regex-based font-lock-keywords for input, which was definitely a step backward from the rich highlighting in source buffers.

Initially I didn’t even bother to research using tree-sitter font-lock in comint, as assumed that would be something quite complicated. Turns out the fix was surprisingly easy.

Font-Lock: comint-fontify-input-mode

Emacs 29.1 introduced comint-fontify-input-mode, a minor mode that fontifies input regions in comint buffers through an indirect buffer. The idea is simple:

1. You tell comint which major mode to use for input via comint-indirect-setup-function.
2. Comint creates an indirect buffer and runs that mode in it.
3. When fontifying, comint splits the buffer into output and input regions. Output gets the comint buffer’s own font-lock; input is fontified in the indirect buffer using the full major mode – including tree-sitter.

Here’s all it took for neocaml’s REPL:

(define-derived-mode neocaml-repl-mode comint-mode "OCaml-REPL"
  ;; ... existing setup ...

  ;; Tree-sitter fontification for REPL input
  (setq-local comint-indirect-setup-function #'neocaml-mode)
  (comint-fontify-input-mode))

That’s it. REPL input now gets the exact same tree-sitter font-lock as .ml buffers. The existing font-lock-keywords for output (error messages, warnings, val/type results) keep working as before – they only apply to output regions.

Important: comint-fontify-input-mode is incompatible with comint-use-prompt-regexp – the two features can’t be active at the same time. Most modern comint-derived modes don’t set comint-use-prompt-regexp to t, so this usually isn’t an issue.

Who’s Already Doing This

Two built-in modes use this approach:

• shell.el sets up sh-mode in the indirect buffer (enabled by default via shell-fontify-input-enable)
• ielm.el sets up emacs-lisp-mode (enabled by default via ielm-fontify-input-enable)

On the third-party side, inf-lua and ts-repl both use this pattern with tree-sitter modes. And now there’s also neocaml, of course. :-)

Indentation: comint-indent-input-line-default

Comint also provides indentation delegation via comint-indent-input-line-default and comint-indent-input-region-default. When you set these as indent-line-function and indent-region-function, pressing TAB on an input line delegates indentation to the indirect buffer’s indent-line-function – which will be treesit-indent if the indirect buffer runs a tree-sitter mode.

(setq-local indent-line-function #'comint-indent-input-line-default)
(setq-local indent-region-function #'comint-indent-input-region-default)

shell.el already does this. For your own REPL modes, you can add these two lines alongside the font-lock setup.

The Caveat

Here’s where things get tricky. Tree-sitter parsers are shared between indirect and base buffers (this is by design – see bug#59693). When treesit-indent runs in the indirect buffer, the parser it uses sees the entire comint buffer – prompts, output, previous commands, everything. The parse tree will be full of errors from non-code content.

Font-lock handles this gracefully because comint-fontify-input-mode only applies fontification results to input regions, so garbled parses of output regions are harmless. But indentation is different – treesit-indent looks at the node context around point, and a broken parse tree can confuse it.

In practice, it works better than you’d expect.¹ For simple multi-line expressions, the local tree-sitter nodes at the cursor position are often correct enough for reasonable indentation. But for deeply nested multi-line input, the results can be off.

Because of this, I chose not to enable indentation delegation by default in neocaml’s REPL. Instead, it’s documented as an opt-in configuration for adventurous users.

The Recipe

If you maintain a tree-sitter mode with a comint REPL, here’s the minimal pattern:

(define-derived-mode my-repl-mode comint-mode "My-REPL"
  ;; ... your existing setup ...

  ;; Font-lock: full tree-sitter highlighting for input
  (setq-local comint-indirect-setup-function #'my-ts-mode)
  (comint-fontify-input-mode)

  ;; Indentation: delegate to tree-sitter (experimental)
  (setq-local indent-line-function #'comint-indent-input-line-default)
  (setq-local indent-region-function #'comint-indent-input-region-default))

Consider making these features opt-in via defcustoms, especially the indentation part. And remember that your existing font-lock-keywords for output highlighting (errors, warnings, result values) will continue working – they don’t conflict with comint-fontify-input-mode.

The End

That’s it. Two overlooked comint features, a few lines of setup, and your REPL goes from basic regex highlighting to full tree-sitter support.

Keep hacking!

In my recent article on removing paired delimiters, I mentioned that I kind of miss Vim’s surround.vim experience in Emacs. Well, it turns out someone has done something about it – surround.el brings the core ideas of surround.vim to native Emacs, without requiring Evil mode.

surround.vim (and similar plugins like mini.surround in Neovim) are some of my favorite Vim packages. The idea is so simple and so useful that it feels like it should be a built-in. So I’m happy to see someone took the time to port that beautiful idea to Emacs.

The Core Ideas of surround.vim

For those who haven’t used surround.vim, the concept is straightforward. You have a small set of operations for working with surrounding characters – the delimiters that wrap some piece of text:

• Delete surrounding pair: ds( removes the parentheses around point
• Change surrounding pair: cs(" changes parens to quotes
• Add surrounding pair: ys + motion + character wraps text with a delimiter

That’s basically it. Three operations, consistent keybindings, works everywhere regardless of file type. The beauty is in the uniformity – you don’t need different commands for different delimiters, and you don’t need to think about which mode you’re in.

surround.el in Practice

surround.el is available on MELPA and the setup is minimal:

(use-package surround
  :ensure t
  :bind-keymap ("M-'" . surround-keymap))

You bind a single keystroke (M-' in this example) to surround-keymap, and that gives you access to all the operations through a second keystroke. Here are the commands available in the keymap:

There are also shortcuts for individual characters – pressing an opening delimiter (like () after the prefix does a mark-inner, while pressing the closing delimiter (like )) does a mark-outer.

A Short Walkthrough

Let’s see how this works in practice. Starting with the word Hello (with point somewhere on it):

Surround – M-' s " wraps the symbol at point with quotes:

Hello  →  "Hello"

Change – M-' c " ( changes the surrounding quotes to parens:

"Hello"  →  (Hello)

Mark inner – M-' i ( selects just the text inside the parens:

(|Hello|)    ;; "Hello" is selected

Mark outer – M-' o ( (or M-' )) selects the parens too:

|( Hello)|   ;; "(Hello)" is selected

Delete – M-' d ( removes the surrounding parens:

(Hello)  →  Hello

Kill – M-' k ( kills the text inside the pair (leaving the delimiters gone too), while M-' K ( kills everything including the delimiters.

Inner vs. Outer

Like surround.vim, surround.el distinguishes between “inner” (just the content between delimiters) and “outer” (content plus the delimiters themselves). The i and k commands operate on inner text, o and K on outer.

There’s also an “auto” mode – the default for i and k – that behaves as inner when you type an opening character and outer when you type a closing character. So M-' ( marks inner, M-' ) marks outer. Handy shortcut if your fingers remember it (I’m still building the muscle memory).

One caveat: auto mode can’t distinguish inner from outer for symmetric pairs like quotes (", '), since the opening and closing character are the same. In those cases it defaults to inner.

How It Differs from Vim

The biggest difference is in how you surround text. In Vim, surround.vim uses motions – ysiw( means “surround inner word with parens.” In Emacs, surround.el operates on the active region or the symbol at point. So the typical workflow is: select something, then M-' s (.

This actually pairs beautifully with expreg (which I wrote about recently). Use expreg to incrementally select exactly the text you want, then M-' s to wrap it. It’s a different rhythm than Vim’s motion-based approach, but once you get used to it, it feels natural.

The other operations (d, c, k, i, o) work similarly to their Vim counterparts – you invoke the command and then specify which delimiter you’re targeting.

When to Use It

surround.el fills a specific niche:

• Using electric-pair-mode? Then surround.el is an excellent complement. electric-pair-mode handles auto-pairing when you type delimiters, but offers nothing for removing, changing, or wrapping existing text with delimiters. surround.el fills exactly that gap.

• Using smartparens? You probably don’t need surround.el – smartparens already has sp-unwrap-sexp, sp-rewrap-sexp, and friends. The overlap is significant, and adding another package on top would just be confusing.

• Using paredit? Same story for Lisp code – paredit has you covered with paredit-splice-sexp, paredit-wrap-round, and so on. But if you want the surround experience in non-Lisp buffers, surround.el is a good pick.

My current setup is paredit for Lisps, electric-pair-mode for everything else, and I’m adding surround.el to complement the latter. Early days, but it feels right.

Wrapping Up

If you’ve ever wondered whether some Vim feature you miss exists in Emacs – the answer is always yes. It’s Emacs. Of course someone has written a package for it. Probably several, in fact… Admittedly, I discovered surround.el only when I had decided to port surround.vim to Emacs myself. :D

That’s all I have for you today. Keep hacking!

The buffer-guardian Emacs package provides buffer-guardian-mode, a global mode that automatically saves buffers without requiring manual intervention.

By default, buffer-guardian-mode saves file-visiting buffers when:

• Switching to another buffer.
• Switching to another window or frame.
• The window configuration changes (e.g., window splits).
• The minibuffer is opened.
• Emacs loses focus.

In addition to regular file-visiting buffers, buffer-guardian-mode also handles specialized editing buffers used for inline code blocks, such as org-src (for Org mode) and edit-indirect (commonly used for Markdown source code blocks). These temporary buffers are linked to an underlying parent buffer. Automatically saving them ensures that modifications made within these isolated code environments are correctly propagated back to the original Org or Markdown file.

If this package enhances your workflow, please show your support by starring buffer-guardian on GitHub to help more users discover its benefits.

Other features that are disabled by default:

• Save the buffer even if a window change results in the same buffer being selected. (Variable: buffer-guardian-save-on-same-buffer-window-change)
• Save all file-visiting buffers periodically at a specific interval. (Variable: buffer-guardian-save-all-buffers-interval)
• Save all file-visiting buffers after a period of user inactivity. (Variable: buffer-guardian-save-all-buffers-idle)
• Prevent auto-saving remote files. (Variable: buffer-guardian-inhibit-saving-remote-files)
• Prevent saving files that do not exist on disk. (Variable: buffer-guardian-inhibit-saving-nonexistent-files)
• Set a maximum buffer size limit for auto-saving. (Variable: buffer-guardian-max-buffer-size)
• Ignore buffers whose names match specific regular expressions. (Variable: buffer-guardian-exclude-regexps)
• Use custom predicate functions to determine if a buffer should be saved. (Variable: buffer-guardian-predicate-functions)

(Buffer Guardian runs in the background without interrupting the workflow. For example, the package safely aborts the auto-save process if the file is read-only, if the file’s parent directory does not exist, or if the file was modified externally. Additionally, it gracefully catches and logs errors if a third-party hook attempts to request user input, ensuring that the editor never freezes during an automatic background save.)

Installation

Installation from MELPA

To install buffer-guardian from MELPA:

1. If you haven’t already done so, add MELPA repository to your Emacs configuration.
2. Add the following code to your Emacs init file to install buffer-guardian from MELPA:

(use-package buffer-guardian
  :custom
  ;; When non-nil, include remote files in the auto-save process
  (buffer-guardian-inhibit-saving-remote-files t)

  ;; When non-nil, buffers visiting nonexistent files are not saved
  (buffer-guardian-inhibit-saving-nonexistent-files nil)

  ;; Save the buffer even if the window change results in the same buffer
  (buffer-guardian-save-on-same-buffer-window-change t)

  ;; Non-nil to enable verbose mode to log when a buffer is automatically saved
  (buffer-guardian-verbose nil)

  ;; Save all buffers after N seconds of user idle time. (Disabled by default)
  ;; (buffer-guardian-save-all-buffers-idle 30)

  :hook
  (after-init . buffer-guardian-mode))

Alternative installation: Doom Emacs

Here is how to install buffer-guardian on Doom Emacs:

1. Add to the ~/.doom.d/packages.el file:

(package! buffer-guardian
  :recipe
  (:host github :repo "jamescherti/buffer-guardian.el"))

1. Add to ~/.doom.d/config.el:

(after! buffer-guardian
  ;; When non-nil, include remote files in the auto-save process
  (setq buffer-guardian-inhibit-saving-remote-files t)

  ;; When non-nil, buffers visiting nonexistent files are not saved
  (setq buffer-guardian-inhibit-saving-nonexistent-files nil)

  ;; Save the buffer even if the window change results in the same buffer
  (setq buffer-guardian-save-on-same-buffer-window-change t)

  ;; Non-nil to enable verbose mode to log when a buffer is automatically saved
  (setq buffer-guardian-verbose nil)

  ;; Save all buffers after N seconds of user idle time. (Disabled by default)
  ;; (setq buffer-guardian-save-all-buffers-idle 30)

  (buffer-guardian-mode 1))

1. Run the doom sync command:

doom sync

Configuration

You can customize buffer-guardian to fit your workflow. Below are the main customization variables:

Triggers

• buffer-guardian-save-on-focus-loss (Default: t): Save when the Emacs frame loses focus.
• buffer-guardian-save-on-minibuffer-setup (Default: t): Save when the minibuffer opens.
• buffer-guardian-save-on-buffer-switch (Default: t): Save when window-buffer-change-functions runs.
• buffer-guardian-save-on-window-selection-change (Default: t): Save when window-selection-change-functions runs.
• buffer-guardian-save-on-window-configuration-change (Default: t): Save when window-configuration-change-hook runs.
• buffer-guardian-save-on-same-buffer-window-change (Default: nil): Save the buffer even if the window change results in the same buffer.

Timers

• buffer-guardian-save-all-buffers-interval (Default: nil): Save all buffers periodically every N seconds.
• buffer-guardian-save-all-buffers-idle (Default: nil): Save all buffers after N seconds of user idle time.

Exclusions and Filters

• buffer-guardian-inhibit-saving-remote-files (Default: t): Prevent auto-saving remote files.
• buffer-guardian-inhibit-saving-nonexistent-files (Default: t): Prevent saving files that do not exist on disk.
• buffer-guardian-exclude-regexps (Default: nil): A list of regular expressions for file names to ignore.
• buffer-guardian-max-buffer-size (Default: nil): Maximum buffer size (in characters) to save. Set to 0 or nil to disable.
• buffer-guardian-predicate-functions (Default: nil): List of predicate functions to determine if a buffer should be saved.

Specialized Buffers (Inline Code Blocks)

• buffer-guardian-handle-org-src (Default: t): Enable automatic saving for org-src buffers.
• buffer-guardian-handle-edit-indirect (Default: t): Enable automatic saving for edit-indirect buffers.

Advanced

• buffer-guardian-save-all-buffers-trigger-hooks: A list of hooks that trigger saving all modified buffers. Defaults to nil.
• buffer-guardian-save-trigger-functions: A list of functions to advise. A :before advice will save the current buffer before these functions execute.
• buffer-guardian-verbose (Default: nil): Enable logging messages when a buffer is saved.

Author and License

The buffer-guardian Emacs package has been written by James Cherti and is distributed under terms of the GNU General Public License version 3, or, at your choice, any later version.

Copyright (C) 2026 James Cherti

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program.

Links

• buffer-guardian.el @GitHub

Other Emacs packages by the same author:

• minimal-emacs.d: This repository hosts a minimal Emacs configuration designed to serve as a foundation for your vanilla Emacs setup and provide a solid base for an enhanced Emacs experience.
• compile-angel.el: Speed up Emacs! This package guarantees that all .el files are both byte-compiled and native-compiled, which significantly speeds up Emacs.
• outline-indent.el: An Emacs package that provides a minor mode that enables code folding and outlining based on indentation levels for various indentation-based text files, such as YAML, Python, and other indented text files.
• easysession.el: Easysession is lightweight Emacs session manager that can persist and restore file editing buffers, indirect buffers/clones, Dired buffers, the tab-bar, and the Emacs frames (with or without the Emacs frames size, width, and height).
• vim-tab-bar.el: Make the Emacs tab-bar Look Like Vim’s Tab Bar.
• elispcomp: A command line tool that allows compiling Elisp code directly from the terminal or from a shell script. It facilitates the generation of optimized .elc (byte-compiled) and .eln (native-compiled) files.
• tomorrow-night-deepblue-theme.el: The Tomorrow Night Deepblue Emacs theme is a beautiful deep blue variant of the Tomorrow Night theme, which is renowned for its elegant color palette that is pleasing to the eyes. It features a deep blue background color that creates a calming atmosphere. The theme is also a great choice for those who miss the blue themes that were trendy a few years ago.
• Ultyas: A command-line tool designed to simplify the process of converting code snippets from UltiSnips to YASnippet format.
• dir-config.el: Automatically find and evaluate .dir-config.el Elisp files to configure directory-specific settings.
• flymake-bashate.el: A package that provides a Flymake backend for the bashate Bash script style checker.
• flymake-ansible-lint.el: An Emacs package that offers a Flymake backend for ansible-lint.
• inhibit-mouse.el: A package that disables mouse input in Emacs, offering a simpler and faster alternative to the disable-mouse package.
• quick-sdcv.el: This package enables Emacs to function as an offline dictionary by using the sdcv command-line tool directly within Emacs.
• enhanced-evil-paredit.el: An Emacs package that prevents parenthesis imbalance when using evil-mode with paredit. It intercepts evil-mode commands such as delete, change, and paste, blocking their execution if they would break the parenthetical structure.
• stripspace.el: Ensure Emacs Automatically removes trailing whitespace before saving a buffer, with an option to preserve the cursor column.
• persist-text-scale.el: Ensure that all adjustments made with text-scale-increase and text-scale-decrease are persisted and restored across sessions.
• pathaction.el: Execute the pathaction command-line tool from Emacs. The pathaction command-line tool enables the execution of specific commands on targeted files or directories. Its key advantage lies in its flexibility, allowing users to handle various types of files simply by passing the file or directory as an argument to the pathaction tool. The tool uses a .pathaction.yaml rule-set file to determine which command to execute. Additionally, Jinja2 templating can be employed in the rule-set file to further customize the commands.
• kirigami.el: The kirigami Emacs package offers a unified interface for opening and closing folds across a diverse set of major and minor modes in Emacs, including outline-mode, outline-minor-mode, outline-indent-minor-mode, org-mode, markdown-mode, vdiff-mode, vdiff-3way-mode, hs-minor-mode, hide-ifdef-mode, origami-mode, yafolding-mode, folding-mode, and treesit-fold-mode. With Kirigami, folding key bindings only need to be configured once. After that, the same keys work consistently across all supported major and minor modes, providing a unified and predictable folding experience.

Security reminder: If you use kubernetes-el, don't update for now, and you might want to check your installation if you updated it recently. The repo was compromised. (Analysis, Reddit discussion, lobste.rs) If you use Emacs 31, please consider enabling package-review-policy.

There were a number of lively conversations around Emacs Solo (142 comments on HN), Emacs and Vim in the age of AI (52 comments on Reddit, 138 on HN), and agent-shell 0.47 (62 on Reddit). Also, Prot has posted the video and text of his talk Computing in freedom with GNU Emacs (YouTube 42:40, Video with Q&A, more links in the community section).

• Upcoming events (iCal file, Org):
  • M-x Research: TBA https://m-x-research.github.io/ Wed Mar 18 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Thu Mar 19 0000 Asia/Singapore
  • EmacsSF (in person): coffee.el in SF https://www.meetup.com/emacs-sf/events/313776893/ Sat Mar 21 1100 America/Los_Angeles
  • Emacs Berlin: Emacs-Berlin Hybrid Meetup https://emacs-berlin.org/ Wed Mar 25 1100 America/Vancouver - 1300 America/Chicago - 1400 America/Toronto - 1800 Etc/GMT - 1900 Europe/Berlin - 2330 Asia/Kolkata – Thu Mar 26 0200 Asia/Singapore
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Mar 28 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 0930 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
• Emacs configuration:
  • Making Emacs Your Own « Here's The Beef (@BeefGriller@dice.camp)
  • Emacs Redux: use-short-answers: The Modern Way to Tame yes-or-no Prompts (Irreal)
  • Two Years of Emacs Solo: 35 Modules, Zero External Packages, and a Full Refactor (Reddit, HN, lobste.rs)
  • minimal-emacs.d Release 1.4.0​ (Reddit)
  • Brainiac v1.2 released — Kemal's Braindump (Codeberg, Reddit) - note-taking and task-management-centered Emacs config
• Emacs Lisp:
  • futur 1.2 (Reddit) futur-abort, futur-funcall, futur-p, preliminary support for running Elisp code in subprocesses and sandbox
• Appearance:
  • Emacs Redux: Taming Font-Lock with font-lock-ignore
  • Emacs Redux: Buffer-Local Face Remapping with face-remap-add-relative
  • Customizing Font-Lock in the Age of Tree-sitter (Reddit)
  • andros/comet.el: Cursor comet trail effect for Emacs - comet.el - Andros's repositories (@andros@activity.andros.dev)
• Navigation:
  • Nifty little modal editing implementation - selected.el, special keymap when region is active
  • Emacs Redux: isearch-lazy-count: Built-in Search Match Counting
  • kramo/scroll-beyond.el: An Emacs package to enable scrolling the point beyond window bounds - Codeberg.org (@kramo@chaos.social)
  • vmargb/arrow.el: Elisp implementation of arrow.nvim per-project and file-local bookmarks · GitHub (Reddit)
• Dired:
  • Chris Maiorana: The Emacs Way: Moving and Renaming Files
• Writing:
  • Re: markdown-ts-mode maturation for Emacs 31 - Rahul Martim Juliato - roadmap for markdown-ts, help wanted
  • lorniu/gt.el: Translator via engines such as Google, Bing, deepL, StarDict and Youdao, also support LLMs like ChatGPT, DeepSeek and so on. · GitHub (@kf@sonomu.club)
• Org Mode:
  • Thaodan/org-note-auto-save: Auto-save org-note buffer - Codeberg.org (@thaodan@mastodon.social)
  • niqc/org-dynamic-templates: Package for define template folder for org files - Codeberg.org (Reddit)
  • Sacha Chua: Emacs Lisp and NodeJS: Getting the bolded words from a section of a Google Document
  • mjamagon/arrow-lang: Arrow DSL for emacs · GitHub (Reddit) - dataflow pipeline language for Org Babel
  • Sacha Chua: Org Mode: Export HTML, copy files, and serve the results via simple-httpd so that media files work
  • Building a cli app to query org with clime v0.3 (Reddit)
• Coding:
  • Mike Olson - Beta: Emacs Multi-LSP support for Python and Typescript frameworks - looking for Emacs users to try it out (@mwolson.org, @mikeozen)
  • Emacs Redux: Code Formatting in Emacs (Irreal)
  • Emacs Redux: Removing Paired Delimiters in Emacs (Irreal, Irreal)
  • Einar Mostad: Fix error with Cider Clojure REPL in Emacs on Guix
  • [EMACS LAB #2] Do zero a uma IDE para programar em C (parte 2) (01:17:59)
  • Philip Kaludercic: Emacs after Magit
  • Rebasing in Magit (@lobsters@mastodon.social)
  • Перебазирование в Magit / Хабр (@habr@zhub.link)
  • Release v0.4.0 · bbatsov/neocaml · GitHub - bugfix (@batsov.net)
• Shells:
  • rwc9u/emacs-libgterm: Terminal emulator for Emacs using libghostty-vt (Ghostty's terminal engine) · GitHub (Reddit)
  • cashmeredev/kitty-graphics.el: Display images in terminal Emacs (emacs -nw) via the Kitty graphics protocol
• Multimedia:
  • Sacha Chua: Comparing pronunciation recordings across time
  • Sacha Chua: Small steps towards using OpenAI-compatible text-to-speech services with speechd-el or emacspeak
• Fun:
  • Solo-RPG-mode for Emacs - TTRPG-Hangout.com (Github, @enfors@ttrpg-hangout.social)
  • vkazanov/elcity: A simple SimCity clone in Emacs Lisp · GitHub (Reddit)
• AI:
  • Emacs and Vim in the Age of AI (Reddit, HN, lobste.rs)
  • Using Terminal Coding Agents from Emacs
  • Randy Ridenour: Convert Claude Quizzes to Emacs Org Mode (@randyridenour@zirk.us, Irreal)
  • agent-shell 0.47 updates (Reddit)- claude-code-acp renamed, bootstrapping and resuming
  • James Dyer: Ollama Buddy - In-Buffer LLM Streaming
  • 038 Ollama Buddy - Tool Calling and modifying files with an ediff session #emacs #ollama (02:12)
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-03-10 / week 10
  • Protesilaos Stavrou: Computing in freedom with GNU Emacs (YouTube 42:40, Reddit, lobste.rs, Irreal, Video with Q&A, other post)
  • Emacs Carnival March 2026: Mistakes and Misconceptions
    • Emacs Carnival de Marzo - Confusiones y prejuicios | Texaco blog (@texaco@defcon.social)
    • Emacs carnival: Mistakes and misconceptions (@ericsfraga@fediscience.org)
    • noa ks: You don't not need the mouse
  • Eric MacAdie: 2026-02 Austin Emacs Meetup
  • Low Tech High Life: Emacs magia y liberación · Inicio (Spotify, @alvarmaciel@mastodon.social)
  • Humanities in the Machine - Blain Smith - mentions RMS, GNU, and Emacs
• Other:
  • Chris Maiorana: The Emacs Way: Create Directories
  • Indexing Info Manuals — Alex Carney (@alcarney@mastodon.social)
  • Emacs Internal #03: Tagged Union, Tagged Pointer, and Poor Man's Inheritance | The Cloudlet (Reddit, HN, lobste.rs)
  • reka: A window manager inside of Emacs for the Wayland world (Reddit) - mentioned in Separating the Wayland Compositor and Window Manager
  • chaoswork/appine: using a dynamic module that allows you to embed native macOS views (WebKit, PDFKit etc.) directly inside Emacs windows (Reddit)
  • My little Emacs OTG setup (Reddit)
  • Emacs running on my iPad. - using ish
• Emacs development:
  • emacs-devel: long discussion about deprecated code, warnings, and compat release schedule
  • Merge remote-tracking branch 'origin/scratch/error-API'
  • Add new function 'ensure-proper-list' (bug#80598)
  • Add references to "User Lisp" Info node where applicable
  • etags-regen: Don't try to generate tags during completion, by default
  • * etc/NEWS: Announce 'package-vc-install-from-checkout' obsoletion
  • Add 'xref-mouse-mode' minor mode
  • ; Add missing documentation for new 'cus-edit' bindings
  • (smerge-refine-regions): Refactor a bit and work between buffers
  • Improve the error API
• New packages:
  • buffer-guardian: Automatically Save Buffers Without Manual Intervention (MELPA)
  • ekg-agent: Agent tools for ekg (MELPA)
  • ekg-denote: Denote integration for ekg (MELPA)
  • markdown-table-wrap: Word-wrap GFM pipe tables to fit window width (MELPA)
  • stan-ts-mode: Major mode for editing Stan files (MELPA)

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

You can comment on Mastodon or e-mail me at sacha@sachachua.com.

A perennial problem for Emacs users are the yes/no prompts that require answering “yes” or “no” instead of just “y” or “n”. The usual solution—adopted by almost everyone—is to alias yes-or-no-p to y-or-n-p. Sometime around Emacs 28 or 29 the new variable use-short-answers was introduced as another way of solving the problem.

The last time I wrote about solving the yes-or-no-p problem, I said,

I’ve had my original aliasing code for at least 17 years and see no reason to change it. When use-short-answers was first introduced, I thought I should adopt it but I never did and as far as I can see, it doesn’t make any difference.

That statement was wrong in two ways. First, as related by Bozhidar Batsov, the alias trick doesn’t always work with native compilation because the call to yes-or-no-p may have been compiled before the alias is made. For that reason, use-short-answers is the better solution because it always work.

The second way it was wrong is that when I went to add use-short-answers to my init.el, I discovered that I had already done so, probably back in Emacs 29.

Keybaord

noctuid/general.el: More convenient key definitions in emacs, is a critical package for my usage of Emacs.

One of the features of Emacs is the keybindings that are usable in the program. Keybindings is another way of saying keyboard commands. The base program comes with its own keybindings. Every time you add a package to the program, it comes with it’s own keybindings or it asks you to set keybindings for its important functions. You write a function in elisp and it is more useful if you assign a keybinding to it. Soon you are swimming in keybindings and you can’t remember them. There are several ways to solve this problem. Extensive transient menus is one of them. kickingvegas/casual-suite: Casual Suite - An umbrella package to support a single install point for all Casual user interfaces. is an attempt to do that. I am going to write about that in a future article. Another solution is general.el.

I am going to tackle my solution to the problem by using general.el.

Keybindings and the Problems With Them

I love keybindings. It is easier to use a program if you know the keybindings which let you perform functions. You don’t have to mouse over to a menu or search for a command when you know the keybindings. Makes your hands not move from the keyboard. Jeff Raskin said in defense of keeping his hands on the keyboard, “You shouldn’t have to live, a hand to mouse existence.” The problem is that there are too many of them and since they are set by someone else, it is difficult to remember them.

I wanted a system which lets me set my own keybindings for my often used commands. The reasoning is that if I am setting my own keybindings, then it is more likely that I will remember them. General.el lets me do that.

Setting Up the Usual Markdown Commands

#+begin_src emacs-lisp
(general-define-key
 :keymaps 'markdown-mode-map
 :prefix "s-o"
 "b" '(markdown-insert-bold :which-key "md bold")
 "q" '(markdown-insert-blockquote :which-key "md blockquote")
 "c" '(markdown-insert-code :which-key "md code")
 "i" '(markdown-insert-italic :which-key "md italic")
 "j" '(markdown-move-list-item-down :which-key "md list dn")
 "k" '(markdown-move-list-item-up :which-key "md list up")
 "l" '(markdown-insert-link :which-key "md link")
 "f" '(markdown-insert-footnote :which-key "md footnote")
 "p" '(md-capture :which-key "md capture")
 "t" '(markdown-insert-table :which-key "md table")
 "u" '(markdown-move-subtree-up :which-key "md item up")
 "d" '(markdown-move-subtree-down :which-key "md item down"))
#+end_src

Wanted to standardize on a leader key. In my case, it made sense to use s-o. In the Emacs world on macOS s is the ⌘key. I type the leader key and then another key to achieve the function assigned to it. Thus if I want to bold something, I can type s-o b and Emacs puts in four asterisks with the cursor between the four asterisks. Or, I can select something which I want to be bold, press the keyboard command s-o b and it gets the syntax of two asterisks surrounding the selected text. I have a whole list of commands tied to Markdown mode assigned to the s-o leader key. Since they follow a pattern and they are chosen by me. It is easier to remember them.

Setting Up the Usual Org-mode Commands

Org-mode is where I spend all my time, and it does a whole lot. The Org-mode commands are broken up into a few sections. These are the usual syntax commands. You have to specify them first, like,

#+begin_src emacs-lisp
;; general.el
(defun my/org-bold () (interactive) (org-emphasize ?*))
(defun my/org-code () (interactive) (org-emphasize ?~))
(defun my/org-italic () (interactive) (org-emphasize ?/))
(defun my/org-clear () (interactive) (org-emphasize ? ))
(defun my/org-strikethrough () (interactive) (org-emphasize ?+))
(defun my/org-underline () (interactive) (org-emphasize ?_))
(defun my/org-verbatim () (interactive) (org-emphasize ?=))
#+end_src

and,

#+begin_src emacs-lisp
(general-define-key
 :keymaps 'org-mode-map
 :prefix "s-o"
 "a" '(org-agenda :which-key "org agenda")
 "b" '(my/org-bold :which-key "org bold")
 "C" '(org-capture :which-key "org capture")
 "c" '(my/org-code :which-key "org code")
 "i" '(my/org-italic :which-key "org italic")
 "e" '(org-emphasize :which-key "org emph")
 "l" '(my/org-insert-link-dwim :which-key "org ins link")
 "s" '(org-schedule :which-key "org sch")
 "t" '(org-todo :which-key "org todo"))
#+end_src

Because I use Org-mode extensively this list includes a few commands that are not syntax related (agenda, capture, schedule and todo). They are commands I use all the time and the s-o leader key is convenient. This is a list of syntax commands and four function commands which get extensive use in Org-mode.

Navigation Commands

These are commands which let me move between headers in Org-mode:

#+begin_src emacs-lisp
(general-define-key
 :keymaps 'org-mode-map
 "M-n" 'org-next-visible-heading
 "M-p" 'org-previous-visible-heading)
#+end_src

There are additional navigation commands which get used for every mode:

#+begin_src emacs-lisp
(general-define-key
 ;; Move to beginning/end of buffer
 "s-<up>" 'beginning-of-buffer
 "s-<down>" 'end-of-buffer

 ;; Move to beginning/end of line
 "s-<left>" 'beginning-of-line
 "s-<right>" 'end-of-line)
#+end_src

Commands Which Deal With Emacs

Now we come to the bulk of the commands that I have set in general.el. These have to be assigned to a leader key. I chose M-o since the right option key and the o are readily accessible. There are many keys assigned to this leader-key. Firstly, a set of keys which are accessed regularly.

#+begin_src emacs-lisp
(general-create-definer my-leader-def
  :prefix "M-o"
  :non-normal-prefix "M-o")
(my-leader-def
  ;; Top level functions
  "." '(find-file :which-key "find file")
  ";" '(consult-recent-file :which-key "recent files")
  "/" '(bufferfile-rename :which-key "rename file")
  "TAB" '(switch-to-prev-buffer :which-key "previous buffer")
  "r" '(repeat :which-key "repeat")
  "g" '(avy-goto-char-timer :which-key "avy char timer")
  "p" '(org-capture :which-key "org-capture")
  "x" '(execute-extended-command :which-key "execute command")
  "+" '(tab-bar-new-tab :which-key "tab new")
  "-" '(tab-close :which-key "tab close")
  "1" '(tab-previous :which-key "tab previous")
  "2" '(tab-next :which-key "tab next")
  "9" '(my/scroll-up-half-page :which-key "scroll up")
  "0" '(my/scroll-down-half-page :which-key "scroll down")
  "<up>" '(push-mark-command :which-key "push mark")
  "<left>" '(backward-forward-previous-location :which-key "previous location")
  "<right>" '(backward-forward-next-location :which-key "next location")
#+end_src

This group went through changes initially. I was trying to see how often they got used. I keep a close watch on the frequency of use to get an idea of its utility. This group changes often.

#+begin_src emacs-lisp
  ;; Applications
  "a" '(nil :which-key "applications")
  "ao" '(org-agenda :which-key "org-agenda")
  "ac" '(org-capture :which-key "org-capture")
  "ab" '(nil :which-key "browse url")
  "abc" '(browse-url-chrome :which-key "chrome")
  "av" '(nil :which-key "avy")
  "avc" '(avy-goto-char-2 :which-key "avy goto char")
  "avp" '(avy-goto-parens :which-key "avy goto parens")
  "ad" '(dired :which-key "dired")
#+end_src

A set of keys assigned to “applications.” Thus M-o a and then a key to call the function.

#+begin_src emacs-lisp
  ;; Buffers
  "b" '(nil :which-key "buffer")
  "bb" '(switch-to-buffer :which-key "switch-to-buffer")
  "bc" '(consult-buffer :which-key "consult-buffer")
  "bd" '(kill-buffer :which-key "kill-buffer")
  "be" '(my/kill-other-buffers :which-key "kill other buffers")
  "bf" '(my/copy-buffer-file-path-to-clipboard :which-key "copy file path")
  "bi" '(ibuffer :which-key "ibuffer")
  "bk" '(my/save-and-close-this-buffer :which-key "save-kill-buffer")
  "bm" '(nil :which-key "bookmark")
  "bmd" '(bookmark-delete :which-key "bookmark delete")
  "bmj" '(bookmark-jump :which-key "bookmark jump")
  "bms" '(bookmark-set :which-key "bookmark set")
  "bn" '(next-buffer :which-key "next-buffer")
  "bo" '(org-switchb :which-key "org-switchb")
  "bp" '(previous-buffer :which-key "previous-buffer")
  "bR" '(revert-buffer :which-key "revert-buffer")
  "br" '(bufferfile-rename :which-key "rename buffer")
  "bs" '(scratch :which-key "scratch")
#+end_src

A set of keys assigned to M-o b and then a key. Buffer related. Except the ones for bookmarks. It was mnemonically consistent to have them here.

#+begin_src emacs-lisp
  ;;Consult
  "c" '(nil :which-key "consult")
  "cd" '(consult-dir :which-key "con dir")
  "cg" '(consult-grep :which-key "con grep")
  "ch" 'consult-org-heading :which-key "con org heading"
  "cl" '(consult-line :which-key "con line")
  "cn" '(consult-notes :which-key "con notes")
  "co" '(consult-outline :which-key "con outline")
  "cy" '(consult-yasnippet :which-key "con yasnippet")
  "cb" '(nil :which-key "bookmark/buffer")
  "cbo" '(consult-bookmark :which-key "con bookmark")
  "cbu" '(consult-buffer :which-key "con buffer")
  ;;Consult-register
  "cr" '(nil :which-key "consult-register")
  "crr" '(consult-register :which-key "con register")
  "crs" '(consult-register-store :which-key "con reg store")
#+end_src

These are the keys set for minad/consult: :mag: consult.el - Search and navigate via completing-read. M-o c and then the relevant key. This group gets used a lot every day. I love consult. Thank you Howard Melman for pointing me to it.

#+begin_src emacs-lisp
  ;; Denote
  "d" '(nil :which-key "denote")
  "dd" '(denote-sort-dired :which-key "denote-sort-dired")
  "dl" '(denote-link :which-key "denote-link")
  "dL" '(denote-add-links :which-key "denote-add-links")
  "dn" '(nil :which-key "denote")
  "dno" '(denote :which-key "denote")
  "dnc" '(my/denote-create-note :which-key "denote choose")
  "db" '(denote-backlinks :which-key "denote-backlinks")
  "dr" '(denote-rename-file :which-key "denote-rename-file")
  "dR" '(denote-rename-file-using-front-matter :which-key "denote-rename-file-using-front-matter")
  "ds" '(denote-subdirectory :which-key "denote-subdir")
  "dt" '(denote-type :which-key "denote-type")
#+end_src

Assigned to M-o d this is my Denote (denote.el) | Protesilaos Stavrou group. I rely on this for all my note-taking. Thank you Prot. You are special.

#+begin_src emacs-lisp
  ;;Elfeed
  "e" '(nil :which-key "elfeed")
  "ee" '(elfeed :which-key "elfeed")
  "eu" '(elfeed-update :which-key "elfeed-update")
#+end_src

This is the skeeto/elfeed: An Emacs web feeds client group. I love reading my feeds in Emacs.

#+begin_src emacs-lisp
;; Files
  "f" '(nil :which-key "files")
  "fb" '(my-list-blog :which-key "blogwriting")
  "fn" '(my-list-notes :which-key "notes")
  "fo" '(my/open-buffer-file-mac :which-key "open buffer in macOS")
  "fm" '(my-list-markdown :which-key "markdown files")
  "ff" '(find-file :which-key "find file")
  "fs" '(save-buffer :which-key "save buffer")
  "fS" '(write-file :which-key "write file")
  "fd" '(dired :which-key "dired")
  "fo" '(reveal-in-osx-finder :which-key "reveal in finder")
  "fr" '(consult-recent-file :which-key "recent files")
  "fR" '(bufferfile-rename :which-key "rename buffer")
#+end_src

This section deals with file operations. Goes to directories, finds files and other assorted tasks.

#+begin_src emacs-lisp
;; Help/emacs
  "h" '(nil :which-key "help/emacs")
  "hv" '(describe-variable :which-key "des. variable")
  "hb" '(describe-bindings :which-key "des. bindings")
  "hM" '(describe-mode :which-key "des. mode")
  "hf" '(describe-function :which-key "des. func")
  "hF" '(describe-face :which-key "des. face")
  "hk" '(describe-key :which-key "des. key")
#+end_src

This is the help section. Gets used multiple times a day.

#+begin_src emacs-lisp
;;set-mode
  "hm" '(nil :which-key "which-mode")
  "hme" '(emacs-lisp-mode :which-key "elisp mode")
  "hmo" '(org-mode :which-key "org mode")
  "hmm" '(markdown-mode :which-key "markdown mode")
  "hmt" '(text-mode :which-key "text mode")
#+end_src

Usually automatic, I use this group rarely. Not sure that I need it but it is here for the time being.

#+begin_src emacs-lisp
  ;; Jumps
  "j" '(nil :which-key "jumps")
  "jr" '(jump-to-register :which-key "registers")
  "jb" '(bookmark-jump :which-key "bookmark jump")
#+end_src

Jumps to the registers and the bookmarks. I do these several times a day and they are repeated commands. Usually achieve this through consult. These are the in built Emacs commands. Might get rid of these.

#+begin_src emacs-lisp
  ;; kirigami
  "k" '(nil :which-key "kirigami")
  "kc" '(kirigami-close-folds :which-key "close all")
  "ko" '(kirigami-open-folds :which-key "open all")
  "kt" '(kirigami-toggle-fold :which-key "toggle folds")
#+end_src

These are the commands for 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…. Useful for long documents, and I have a few of those. Love this developer and this package.

#+begin_src emacs-lisp
  ;; Lisp
  "l" '(nil :which-key "lisp")
  "lb" '(eval-buffer :which-key "eval buffer")
  "ld" '(eval-defun :which-key "eval defun")
  "le" '(eval-expression :which-key "eval expression")
  "lr" '(eval-region :which-key "eval region")
  "ls" '(eval-sexp :which-key "eval sexp")
#+end_src

Learning elisp, this is important.

#+begin_src emacs-lisp
  ;;package
  "hp" '(nil :which-key "package")
  "hpr" '(package-refresh-contents)
  "hpi" '(package-install)
  "hpd" '(package-delete)
  "hps" '(straight-pull-all)
#+end_src

Package management in Emacs. Useful sometimes.

#+begin_src emacs-lisp
  ;; Search
  "s" '(nil :which-key "search")
  "sa" '(avy-goto-char-2 :which-key "avy-goto-char-2")
  "ss" '(isearch-forward :which-key "isearch-forward")
  "sr" '(isearch-backward :which-key "isearch-backward")
  "sp" '(project-search :which-key "project search")
  "si" '(consult-imenu :which-key "consult-imenu")
  "sm" '(consult-mark :which-key "jump to marker")
  "sl" '(consult-goto-line :which-key "Go to line")
#+end_src

Search. Gets used multiple times every day. Useful bunch of commands. Fond of consult-goto-line.

#+begin_src emacs-lisp
  ;;System
  "m" '(nil :which-key "system")
  "m1" '(restart-emacs :which-key "restart emacs")
  "m+" '(tab-bar-new-tab :which-key "tab new")
  "m-" '(tab-close :which-key "tab close")
  "ma" '(read-abbrev-file :which-key "read abbrev file")
  "mc" '(hrm-load-current-lisp-file :which-key "load lisp file")
  "mf" '(my/resources-visit :which-key "visit resources")
  "mr" '(nil :which-key "region")
  "mre" '(er/expand-region :which-key "expand region")
  "mrc" '(er/contract-region :which-key "contract region")
  "mp" '(nil :which-key "palimpsest")
  "mpb" '(palimpsest-move-region-to-bottom :which-key "pal move bottom")
  "mpt" '(palimpsest-move-region-to-top :which-key "pal move top")
  "mm" '(nil :which-key "mark")
  "mml" '(my/mark-line :which-key "mark line")
  "mmb" '(my/mark-block :which-key "mark block")
  "mw" '(writegood-mode :which-key "writegood toggle")
#+end_src

The classification is iffy. This is not all system related. The mnemonic is not useful. However these are a set of commands which get used a lot. I have meshed them into my fingers.

#+begin_src emacs-lisp
  ;; Org-mode
  "o" '(nil :which-key "org-mode")
  "oa" '(org-agenda :which-key "org-agenda")
  "oc" '(org-capture :which-key "org-capture")
  "on" '(recursive-narrow-or-widen-dwim :which-key "narrow")
  "or" '(org-refile :which-key "refile")
  "ot" '(org-todo :which-key "DONE")
  "ou" '(my/org-jump-to-heading-beginning :which-key "jump to heading")
  ;; More Org
  "ol" '(nil :which-key "line/link")
  "olb" '(org-beginning-of-line :which-key "begin of line")
  "ole" '(org-end-of-line :which-key "end of line")
  "oli" '(org-insert-link :which-key "org insert link")
  "olh" '(denote-org-link-to-heading :which-key "org link to heading")
  "ols" '(org-store-link :which-key "org store link")
  ;; Yet More org
  "," '(nil :which-key "more-org")
  ",c" '(org-cycle :which-key "org-cycle")
  ",m" '(my/yank-markdown-as-org :which-key "yank md>org")
  ",n" '(outline-next-visible-heading :which-key "next-heading")
  ",p" '(outline-previous-visible-heading :which-key "previous-heading")
  ",t" '(org-set-tags-command :which-key "set-tags")
  ",u" '(outline-up-heading :which-key "up-heading")
#+end_src

I write primarily in Org-mode and there are a host of things Org can do for you. Not all of these get used all the time. They are Org features which make it better than any other markup language for me.

#+begin_src emacs-lisp
  ;; text
  "t" '(nil :which-key "text")
  "ti" '(indent-whole-buffer :which-key "indent whole buffer")
  "tr" '(isearch-query-replace :which-key "find and replace")
  "ts" '(yas-insert-snippet :which-key "insert yasnippet")
  "tR" '(replace-regexp :which-key "replace-regexp")
  "tt" '(titlecase-dwim :which-key "titlecase")
  "t/" '(my/comment-or-uncomment :which-key "comment")
  ;; date/time
  "td" '(nil :which-key "stamp date/time")
  "tdt" '(my/time-stamp-short :which-key "time-stamp-short")
  "tdd" '(my/date-stamp :which-key "date-stamp")
  ;; word
  "tw" '(nil :which-key "word")
  "twc" '(my/copy-whole-word :which-key "copy whole word")
  "twk" '(my/kill-inner-word :which-key "kill inner word")
  "two" '(copy-as-format-org-mode :which-key "copy as org mode")
  "twm" '(copy-as-format-markdown :which-key "copy as markdown mode")
  "twi" '(org-web-tools-insert-web-page-as-entry :which-key "insert web page as entry")
  "tww" '(org-web-tools-insert-link-for-url :which-key "insert link for url")
  "twl" '(dictionary-lookup-definition :which-key "dictionary lookup")
  "twp" '(my/lookup-word-at-point :which-key "lookup word at point")
#+end_src

This is a collection of things which are text related. Functions which make working with text easier in Emacs. I am always using these. They are critical.

#+begin_src emacs-lisp
  ;; Windows
  "w" '(nil :which-key "window")
  "wl" '(windmove-right :which-key "windmove-right")
  "wh" '(windmove-left :which-key "windmove-left")
  "wk" '(windmove-up :which-key "windmove-up")
  "wj" '(windmove-down :which-key "windmove-down")
  "wd" '(delete-window :which-key "delete-window")
  "wr" '(hsplit-last-buffer :which-key "split-window-right")
  "wb" '(vsplit-last-buffer :which-key "split-window-below")
  "ww" '(appine-open-web-split :which-key "appine-web")
  "wf" '(appine-open-file-split :which-key "appine-file")
#+end_src

Windows management related keyboard commands. I use these several times every day.

#+begin_src emacs-lisp
  ;; Visual
  "v" '(nil :which-key "visual")
  "vm" '(view-mode :which-key "view-mode")
  "vt" '(consult-theme :which-key "load theme")
  "vR" '(read-only-mode :which-key "read only mode"))
#+end_src

This is a strange bunch of commands which don’t get used all that often. I use read-only-mode when the document is critical and needs deliberate editing.

Some of the functions are repeated several times in the setup. Those are important to my use and I am trying to figure out which is the easiest way to get to them. This is going to get cleaned up over time.

I love general.el. It has made it possible to define, remember, and use my own keyboard commands in Emacs. Thank you to the developer.

macosxguru at the gmail thingie.

Thanks: Photo by cottonbro studio: https://www.pexels.com/photo/white-apple-keyboard-on-white-table-5082571/

Yet another neocaml issue taught me something I didn’t know about Emacs. Someone requested that the docs show how to customize font-lock faces per mode rather than globally. The suggested approach used face-remap-add-relative – a function I’d never heard of, despite 20+ years of daily Emacs use. Time to dig in.

The Problem

Let’s say you want type names in OCaml buffers to be displayed in a different color than in, say, Python buffers. The naive approach is to use custom-set-faces or set-face-attribute:

(set-face-attribute 'font-lock-type-face nil :foreground "DarkGreen")

This works, but it’s a global change – every buffer that uses font-lock-type-face will now show types in dark green.

When Global is Fine

To be fair, global face customization is perfectly valid in several scenarios:

• Your theme doesn’t cover certain faces. Many themes only style a subset of the faces that various packages define. If a face looks wrong or unstyled, a global set-face-attribute or custom-set-faces is the quickest fix.

• Your theme makes choices you disagree with. I recently ran into this with the Catppuccin theme – the styling of font-lock-variable-name-face didn’t match how I expected it to look, so I filed a PR. It got closed because different modes interpret that face inconsistently (definitions in Elisp, references in C), making a universal fix impractical for the theme. That’s exactly the kind of situation where you’d want to override the face yourself.

• You want consistent styling everywhere. If you just want all comments to be italic, or all strings to use a specific color regardless of mode, global is the way to go. No need to complicate things with per-buffer remapping.

When Global Isn’t Enough

The problem comes when you bounce between several languages (and let’s be honest, most of us do) and you want different visual treatment depending on the mode. Not all modes use the built-in font-lock faces consistently, and for some – especially markup languages – there’s a lot of room for improvisation in how faces get applied. A global change to font-lock-keyword-face might look great in your Python buffers but terrible in your Org files.

That’s where buffer-local face remapping comes in.

Enter face-remap-add-relative

face-remap-add-relative has been around since Emacs 23 (it lives in face-remap.el), and it does exactly what the name suggests – it remaps a face relative to its current definition, and only in the current buffer. The change is buffer-local, so it won’t leak into other buffers.

Here’s the basic usage:

(face-remap-add-relative 'font-lock-type-face :foreground "DarkGreen")

To apply this automatically in a specific mode, hook it up:

(defun my-ocaml-faces ()
  "Customize faces for OCaml buffers."
  (face-remap-add-relative 'font-lock-type-face :foreground "DarkGreen")
  (face-remap-add-relative 'font-lock-function-name-face :weight 'bold))

(add-hook 'neocaml-mode-hook #'my-ocaml-faces)

Now OCaml buffers get their own face tweaks while everything else stays untouched. You can do the same for any mode – just swap the hook and adjust the faces to taste.

The Magic “Cookie”

face-remap-add-relative returns a cookie – a token you’ll need if you want to undo the remapping later. If you’re just setting things up in a mode hook and leaving them, you can ignore the cookie. But if you want to toggle the remapping on and off, you’ll need to hold onto it:

(defvar-local my-type-face-cookie nil
  "Cookie for type face remapping.")

(defun my-toggle-type-face ()
  "Toggle custom type face in current buffer."
  (interactive)
  (if my-type-face-cookie
      (progn
        (face-remap-remove-relative my-type-face-cookie)
        (setq my-type-face-cookie nil)
        (message "Type face remapping removed"))
    (setq my-type-face-cookie
          (face-remap-add-relative 'font-lock-type-face
                                   :foreground "DarkGreen"))
    (message "Type face remapping applied")))

Note the use of defvar-local – since face remapping is buffer-local, your cookie variable should be too.

A cleaner approach is to wrap this in a minor mode:

(defvar-local my-type-remap-cookie nil)

(define-minor-mode my-type-remap-mode
  "Minor mode to remap type face in current buffer."
  :lighter " TypeRemap"
  (if my-type-remap-mode
      (setq my-type-remap-cookie
            (face-remap-add-relative 'font-lock-type-face
                                     :foreground "DarkGreen"))
    (when my-type-remap-cookie
      (face-remap-remove-relative my-type-remap-cookie)
      (setq my-type-remap-cookie nil))))

Related Functionality

A few more things worth knowing in this area:

• face-remap-set-base – sets the base remapping for a face in the current buffer. Unlike face-remap-add-relative (which layers on top of the existing face), this replaces the face definition entirely for that buffer. Use this when you want to completely override a face rather than tweak it.

• buffer-face-mode / buffer-face-set – a built-in minor mode that remaps the default face in the current buffer. This is what powers M-x buffer-face-set and is handy if you want a different base font in specific buffers (say, a proportional font for prose and a monospace font for code).

• text-scale-adjust (C-x C-= / C-x C--) – the familiar text scaling commands actually use face-remap-add-relative under the hood to remap the default face. So if you’ve ever zoomed text in a single buffer, you’ve been using face remapping without knowing it.

• face-remapping-alist – the buffer-local variable where all of this state is stored. You generally shouldn’t manipulate it directly (that’s what the functions above are for), but it’s useful for debugging – check its value in a buffer to see what remappings are active.

Wrapping Up

I have to admit – I’m a bit embarrassed that face-remap-add-relative has been sitting in Emacs since version 23 and I’d never once used it. Probably because I never felt the need for per-mode face customizations – but I can certainly see why others would, especially when working across languages with very different syntax highlighting conventions.

Working on neocaml has been a gold mine of learning (and relearning). I’m happy to keep sharing the things I discover along the way. Keep hacking!

Bozhidar Batsov has a nice post on delete-pair. It’s almost a case of the Baader-Meinhoff Phenomenon. Five months ago—before I wrote about it—I’d never heard of delete-pair and now it’s popping up on Batsov’s blog. Batsov, himself, doesn’t remember hearing about it before either.

For those who came in late, delete-pair does just what it says on the tin: delete the delimiter at point and its matching closing sibling. It’s actually quite flexible and usable in surprising ways as you can see from the_cecep’s original post that inspired mine.

The delete-pair command came to Batsov’s attention because it interacted poorly with his Neocaml package. That turned out to be because delete-pair makes assumptions that might not hold for languages with unusual syntax.

Batsov’s post is mostly a summary of what he found from researching the deletions of pairs in Emacs. For Lisp languages, all you need is paredit which has multiple ways of removing a delimiter pair. Probably the easiest is paredit-splice-sexp.

There’s also smartparens that also has several ways of removing a delimiter pair and has the advantage of working in all languages, not just Lisps. Batsov finds it too heavyweight for his needs but lots of folks swear by it.

Finally, there’s the builtin electric-pair-mode, which keeps delimiters balanced, pairs nicely with delete-pair, and is probably all most people need.

Take a look at Batsov’s post for more details and for a bit of Elisp that recreates Vim’s vim-surround. I was glad to see his post because I was right on the verge of forgetting delete-pair even though I’ve assigned it a keyboard shortcut.

Continuing my Prelude modernization effort (see the previous post for context), another long-standing third-party dependency I was happy to drop was anzu.

The Problem

When you’re searching with C-s in Emacs, you can see the current match highlighted, but you have no idea how many total matches exist in the buffer or which one you’re currently on. Are there 3 matches or 300? You just don’t know.

The Old Way

For years, I used the anzu package (an Emacs port of anzu.vim) to display match counts in the mode-line. It worked well, but it was yet another third-party dependency to maintain – and one that eventually ended up in the Emacs orphanage, which is never a great sign for long-term maintenance.

The New Way

Emacs 27 introduced isearch-lazy-count:

(setopt isearch-lazy-count t)

With this enabled, your search prompt shows something like (3/47) – meaning you’re on the 3rd match out of 47 total. Simple, built-in, and requires no external packages.

Unlike anzu, which showed counts in the mode-line, isearch-lazy-count displays them right in the minibuffer alongside the search string, which is arguably a better location since your eyes are already there while searching.

Customizing the Format

Two variables control how the count is displayed:

;; Prefix format (default: "%s/%s ")
;; Shows before the search string in the minibuffer
(setopt lazy-count-prefix-format "(%s/%s) ")

;; Suffix format (default: nil)
;; Shows after the search string
(setopt lazy-count-suffix-format nil)

If you prefer the count at the end of the prompt (closer to how anzu felt), you can swap them:

(setopt lazy-count-prefix-format nil)
(setopt lazy-count-suffix-format " [%s/%s]")

Good to Know

The count works with all isearch variants – regular search, regex search (C-M-s), and word search. It also shows counts during query-replace (M-%) and query-replace-regexp (C-M-%), which is very handy for knowing how many replacements you’re about to make.

The counting is “lazy” in the sense that it piggybacks on the lazy highlighting mechanism (lazy-highlight-mode), so it doesn’t add significant overhead. In very large buffers, you might notice a brief delay before the count appears, controlled by lazy-highlight-initial-delay. One thing to keep in mind – if you’ve disabled lazy highlighting for performance reasons, you’ll need to re-enable it, as the count depends on it.

If you haven’t read it already, check out my earlier article You Have No Idea How Powerful Isearch Is for a deep dive into what isearch can do. isearch-lazy-count pairs nicely with all the features covered there.

Between use-short-answers and isearch-lazy-count, that’s two third-party packages I was able to drop from Prelude just by using built-in functionality. Keep hacking!

I recently started a long overdue update of Emacs Prelude, rebasing it on Emacs 29 as the minimum supported version. This has been a great excuse to revisit a bunch of old configuration patterns and replace them with their modern built-in equivalents. One of the first things I updated was the classic yes-or-no-p hack.

The Problem

By default, Emacs asks you to type out the full word yes or no for certain prompts – things like killing a modified buffer or deleting a file. The idea is that this extra friction prevents you from accidentally confirming something destructive, but in practice most people find it annoying and want to just hit y or n.

The Old Way

For decades, the standard solution was one of these:

(fset 'yes-or-no-p 'y-or-n-p)

;; or equivalently:
(defalias 'yes-or-no-p 'y-or-n-p)

This worked by literally replacing the yes-or-no-p function with y-or-n-p at runtime. Hacky, but effective – until native compilation came along in Emacs 28 and broke it. Native compilation can hardcode calls to C primitives, which means fset/defalias sometimes has no effect on yes-or-no-p calls that were already compiled. You’d set it up, and some prompts would still ask for yes or no. Not fun.

The New Way

Emacs 28 introduced the use-short-answers variable:

(setopt use-short-answers t)

That’s it. Clean, discoverable, native-compilation-safe, and officially supported. It makes yes-or-no-p delegate to y-or-n-p internally, so it works correctly regardless of compilation strategy.

If you’re maintaining a config that needs to support older Emacs versions as well, you can do:

(if (boundp 'use-short-answers)
    (setopt use-short-answers t)
  (fset 'yes-or-no-p 'y-or-n-p))

A Word of Caution

The Emacs maintainers intentionally designed yes-or-no-p to slow you down for destructive operations. Enabling use-short-answers removes that friction entirely. In practice, I’ve never accidentally confirmed something I shouldn’t have with a quick y, but it’s worth knowing the tradeoff you’re making.

A Few More Things

If you’re using GUI Emacs, you might also want to disable dialog boxes for a consistent experience:

(setopt use-dialog-box nil)

It’s also worth knowing that the related variable read-answer-short controls the same behavior for multi-choice prompts (the ones using read-answer internally). Setting use-short-answers affects both yes-or-no-p and read-answer.

This is one of those small quality-of-life improvements that Emacs has been accumulating in recent versions. Updating Prelude has been a nice reminder of how many rough edges have been smoothed over. Keep hacking!

In Org Mode, when you use "Export to HTML - As HTML file and open", the resulting HTML file is loaded using a file:// URL. This means you can't load any media files. In my post about pronunciation practice, I wanted to test the playback without waiting for my 11ty-based static site generator to churn through the files.

simple-httpd lets you run a web server from Emacs. By default, the httpd-root is ~/public_html and httpd-port is 8085, but you can configure it to be somewhere else. Here I set it up to create a new temporary directory, and to delete that directory afterwards.

(use-package simple-httpd
  :config
  (setq httpd-root (make-temp-file "httpd" t))
  :hook
  (httpd-stop . my-simple-httpd-remove-temporary-root)
  (kill-emacs . httpd-stop))

(defun my-simple-httpd-remove-temporary-root ()
  "Remove `httpd-root' only if it's a temporary directory."
  (when (file-in-directory-p httpd-root temporary-file-directory)
    (delete-directory httpd-root t)))

The following code exports your Org buffer or subtree to a file in that directory, copies all the referenced local files (if they're newer) and updates the links in the HTML, and then serves it via simple-httpd. Note that it just overwrites everything without confirmation, so if you refer to files with the same name, only the last one will be kept.

(with-eval-after-load 'ox
  (org-export-define-derived-backend 'my-html-served 'html
    :menu-entry
    '(?s "Export to HTML and Serve"
         ((?b "Buffer"  my-org-serve--buffer)
          (?s "Subtree" my-org-serve--subtree)))))

(defun my-org-serve--buffer (&optional async _subtreep visible-only body-only ext-plist)
  (my-org-export-and-serve nil))

(defun my-org-serve--subtree (&optional async _subtreep visible-only body-only ext-plist)
  (my-org-export-and-serve t))

;; Based on org-11ty--copy-files-and-replace-links
;; Might be a good idea to use something DOM-based instead
(defun my-html-copy-files-and-replace-links (info &optional destination-dir)
  (let ((file-regexp "\\(?:src\\|href\\|poster\\)=\"\\(\\(file:\\)?.*?\\)\"")
        (destination-dir (or destination-dir (file-name-directory (plist-get info :file-path))))
        file-all-urls file-name beg
        new-file file-re
        unescaped)
    (unless (file-directory-p destination-dir)
      (make-directory destination-dir t))
    (unless (file-directory-p destination-dir)
      (error "%s is not a directory." destination-dir))
    (save-excursion
      (goto-char (point-min))
      (while (re-search-forward file-regexp nil t)
        (setq file-name (or (match-string 1) (match-string 2)))
        (unless (or (string-match "^#" file-name)
                    (get-text-property 0 'changed file-name))
          (setq file-name
                (replace-regexp-in-string
                 "\\?.+" ""
                 (save-match-data (if (string-match "^file:" file-name)
                                      (substring file-name 7)
                                    file-name))))
          (setq unescaped
                (replace-regexp-in-string
                 "%23" "#"
                 file-name))
          (setq new-file (concat
                          (if info (plist-get info :permalink) "")
                          (file-name-nondirectory unescaped)))
          (unless (org-url-p file-name)
            (let ((new-file-name (expand-file-name (file-name-nondirectory unescaped)
                                                   destination-dir)))
              (condition-case err
                  (when (or (not (file-exists-p new-file-name))
                            (file-newer-than-file-p unescaped new-file-name))
                    (copy-file unescaped new-file-name t))
                (error nil))
              (when (file-exists-p new-file-name)
                (save-excursion
                  (goto-char (point-min))
                  (setq file-re (concat "\\(?: src=\"\\| href=\"\\| poster=\"\\)\\(\\(?:file://\\)?" (regexp-quote file-name) "\\)"))
                  (while (re-search-forward file-re nil t)
                    (replace-match
                     (propertize
                      (save-match-data (replace-regexp-in-string "#" "%23" new-file))
                      'changed t)
                     t t nil 1)))))))))))

(defun my-org-export-and-serve (&optional subtreep)
  "Export current org buffer (or subtree if SUBTREEP) to HTML and serve via simple-httpd."
  (interactive "P")
  (require 'simple-httpd)
  (httpd-stop)
  (unless httpd-root (error "Set `httpd-root'."))
  (unless (file-directory-p httpd-root)
    (make-directory httpd-root t))
  (unless (file-directory-p httpd-root)
    (error "%s is not a directory." httpd-root))
  (let* ((out-file (expand-file-name (concat (file-name-base (buffer-file-name)) ".html")
                                     httpd-root))
         (html-file (org-export-to-file 'my-html-served out-file nil subtreep)))
    ;; Copy all the files and rewrite all the links
    (with-temp-file out-file
      (insert-file-contents out-file)
      (my-html-copy-files-and-replace-links
       `(:permalink "/") httpd-root))
    (httpd-start)
    (browse-url (format "http://localhost:%d/%s"
                        httpd-port
                        (file-name-nondirectory html-file)))))

Now I can use C-c C-e (org-export-dispatch), select the subtree with C-s, and use s s to export a subtree to a webserver and have all the media files work. This took 0.46 seconds for my post on pronunciation practice and automatically opens the page in a browser window. In comparison, my 11ty static site generator took 5.18 seconds for a subset of my site (1630 files copied, 214 files generated), and I haven't yet hooked up monitoring it to Emacs, so I have to take an extra step to open the page in the browser when I think it's finished. I think exporting to HTML and serving it with simple-httpd will be much easier for simple cases like this, and then I can export to 11ty once I'm done with the basic checks.

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

Just a quick post today to note that Protesilaos Stavrou (Prot) has published the video from his FOSS @ Oxford talk that I wrote about yesterday. Actually, he says that it’s a modified version of that talk so I don’t know if a video of the actual talk will appear or not.

In any event, the video tracked very well with the transcript that I wrote about in yesterday’s post. The video is a little easier to follow because you can see the changes to the text that he makes during his talk. If you’re the type of person that gets more out of a video than reading a transcript, be sure to take a look. The video is fairly long at 42 minutes, 40 seconds long so you’ll have to put some time aside for it but it’s definitely worth your while.

I stopped using Magit with Emacs a few months ago. Initially this was just because Magit added a new dependency cond-let that was conflicting the upstream development of a macro by the same name, but I had already taken issue with the number of dependencies such as llama, and generally do not enjoy Transient-based user interfaces, so I ended up sticking with the descision.

First things first: The absence of Magit in my regular arsenal is noticeable and slightly annoying. There are things I have gotten so used to doing via Magit, that I had to look up how I could do them without. And it is about this experience that I want to write about here.

The first and most immediate difference is that when I have to perform some Git-action, I don’t call magit-status (which I had bound to C-c g instead of the default global binding C-x g). Instead I mostly use shell-command (M-!), or more specifically my “fork” shell-command+ that I had extended to always run certain commands asynchronously, such as git or even defer to the respective VC-mode commands. So M-! git diff RET actually calls vc-diff, instead of just spitting the output into “*Async Shell Command*” (even if in this specific case I’d usually invoke C-x v D (vc-root-diff)). Having the bash-completion package installed also helps to find the right flags for git subcommands.

In other operations I can now use VC-mode more effectively. As of Emacs 31, a number of useful features have been added (mostly by the now new Emacs maintainer Sean Whitton) such as the ability to edit previous commit messages by pressing e in the “*vc-changes-log*” buffer, which extends the previous capabilities to just amend an existing commit message more effectively. See etc/NEWS for more details.

But there are useful features in Magit that are actually composite commands. The ones I found missing the most were spinning of branches (creating a new branch and reverting the previous branch to the upstream position) and easy fixups of previous commits. When researching online, an idea I came up upon was to add git alii to my configuration. I have to admit that I was disinclined to do so, again not so much for necessarily technical reasons, but mostly because I associate the usage of a git alias with people who insist on saving time by writing git c instead of git commit (or worse yet, they add a shell alias gc). Instead, I recalled that any subcommand git foo checks if an executable git-foo is in PATH and can defer to that instead. So I wrote scripts for the most common use-cases that I ran into

• git spinoff NEW-BRANCH-NAME, create a new branch NEW-BRANCH-NAME with the commits between HEAD and the upstream state of the current branch, and then reset the current branch to the upstream state.

• git update, is basically just a shorthand for git pull --autostash --rebase.

• git fixup COMMIT, tries to amend the changes in the staging area onto a COMMIT, and then rebase all subsequent commits onto the modified changes.

These are really basic scripts that I just invoke using M-!, no further magic involved.

Some Git commands require user input, which in a terminal would start a TUI editor like vi or GNU nano. As I am executing commands using M-!, this is an issue, since I am not emulating a proper terminal, and do not intend to do so. Magit handles this using the with-editor package, which I have been thinking about using as well, but for now I just set

(setenv "EDITOR" "ed")

in my init.el and have been running with it since. It is not ideal, but slightly funny, and 99% of the time all I have to do is write wq anyway.

All in all this was an interesting exercise, and for now it works well enough. I know I am more in the “integrating development environment” school of Emacs, so some of my practices might appears strange, but I hope some might also be intrigued. Finally, I have to clarify that this post is about how I work with Git, and is not a hit-piece on Magit or anyone working on Magit — the issues I take with Magit are due to my own preferences and requirements, and not normative statements on how everyone should use Git with Emacs.

The other day someone filed an issue against my neocaml package, reporting surprising behavior with delete-pair. My first reaction was – wait, delete-pair? I’ve been using Emacs for over 20 years and I wasn’t sure I had ever used this command. Time for some investigation!

What is delete-pair?

delete-pair is a built-in Emacs command (defined in lisp/emacs-lisp/lisp.el) that deletes a pair of matching characters – typically parentheses, brackets, braces, or quotes. You place point on an opening delimiter, invoke delete-pair, and it removes both the opening and closing delimiter.

Given that it lives in lisp.el, it was clearly designed with Lisp editing in mind originally. And it was probably quite handy back in the day – before paredit came along and made delete-pair largely redundant for Lisp hackers.

Here’s a simple example. Given the following code (with point on the opening parenthesis):

(print_endline "hello")

Running M-x delete-pair gives you:

print_endline "hello"

Simple and useful! Yet delete-pair has no default keybinding, which probably explains why so few people know about it. If you want to use it regularly, you’ll need to bind it yourself:

(global-set-key (kbd "M-s-d") #'delete-pair)

Pick whatever keybinding works for you, of course. There’s no universally agreed upon binding for this one.

The Gotcha

The issue that was reported boiled down to delete-pair not always finding the correct matching delimiter. It uses forward-sexp under the hood to find the matching closer, which means its accuracy depends entirely on the buffer’s syntax table and the major mode’s parsing capabilities. For languages with complex or unusual syntax, this can sometimes lead to the wrong delimiter being removed – not great when you’re trying to be surgical about your edits.

Alternatives for Pair Management

If you work with paired delimiters frequently, delete-pair is just one tool in a rich ecosystem. Here’s a quick overview of the alternatives:

paredit

paredit is the gold standard for structured editing of Lisp code. I’ve been a heavy paredit user for as long as I can remember – if you write any Lisp-family language, it’s indispensable. paredit gives you paredit-splice-sexp (bound to M-s by default), which removes the surrounding delimiters while keeping the contents intact. There’s also paredit-raise-sexp (M-r), which replaces the enclosing sexp with the sexp at point – another way to get rid of delimiters. And of course, paredit prevents you from creating unbalanced expressions in the first place, which is a huge win.

Once you’ve got paredit in your muscle memory, you’ll never think about delete-pair again (as I clearly haven’t).

Let’s see these commands in action. In the examples below, | marks the position of point.

paredit-splice-sexp (M-s) – removes the surrounding delimiters:

;; Before (point anywhere inside the inner parens):
(foo (bar| baz) quux)

;; After M-s:
(foo bar| baz quux)

paredit-raise-sexp (M-r) – replaces the enclosing sexp with the sexp at point:

;; Before:
(foo (bar| baz) quux)

;; After M-r:
(foo bar| quux)

Notice the difference: splice keeps all the siblings, raise keeps only the sexp at point and discards everything else inside the enclosing delimiters.

smartparens

smartparens is the most feature-rich option and works across all languages, not just Lisps. For unwrapping pairs, it offers a whole family of commands:

• sp-unwrap-sexp – removes the enclosing pair delimiters, keeping the content
• sp-backward-unwrap-sexp – same, but operating backward
• sp-splice-sexp (M-D) – removes delimiters and integrates content into the parent expression
• sp-splice-sexp-killing-backward / sp-splice-sexp-killing-forward – splice while killing content in one direction

Here’s how the key ones look in practice:

sp-unwrap-sexp – removes the next pair’s delimiters:

# Before (point on the opening bracket):
result = calculate(|[x, y, z])

# After sp-unwrap-sexp:
result = calculate(|x, y, z)

sp-splice-sexp (M-D) – works like paredit’s splice, removes the innermost enclosing pair:

# Before (point anywhere inside the parens):
result = calculate(x + |y)

# After M-D:
result = calculate x + |y

sp-splice-sexp-killing-backward – splices, but also kills everything before point:

# Before:
result = [first, second, |third, fourth]

# After sp-splice-sexp-killing-backward:
result = |third, fourth

I used smartparens for a while for non-Lisp languages, but eventually found it a bit heavy for my needs.

electric-pair-mode

electric-pair-mode is the built-in option (since Emacs 24.1) that automatically inserts matching delimiters when you type an opening one. It’s lightweight, requires zero configuration, and works surprisingly well for most use cases. I’ve been using it as my go-to solution for non-Lisp languages for a while now.

The one thing electric-pair-mode doesn’t offer is any way to unwrap/remove paired delimiters. The closest it gets is deleting both delimiters when you backspace between an adjacent empty pair (e.g., (|) – pressing backspace removes both parens). But that’s it – there’s no unwrap command. That’s where delete-pair comes in handy as a complement.

A Note on Vim’s surround.vim

Having played with Vim and its various surround.vim-like plugins over the years, I have to admit – I kind of miss that experience in Emacs, at least for removing paired delimiters. surround.vim makes it dead simple: ds( deletes surrounding parens, ds" deletes surrounding quotes. It works uniformly across all file types and feels very natural.

In Emacs, the story is more fragmented – paredit handles it beautifully for Lisps, smartparens does it for everything but is a heavyweight dependency, and electric-pair-mode just… doesn’t do it at all. delete-pair is the closest thing to a universal built-in solution, but its lack of a default keybinding and its reliance on forward-sexp make it a bit rough around the edges.

If you’re using electric-pair-mode and want a simple surround.vim-style “delete surrounding pair” command without pulling in a big package, here’s a little hack that does the trick:

(defun delete-surrounding-pair (char)
  "Delete the nearest surrounding pair of CHAR.
CHAR should be an opening delimiter like (, [, {, or \".
Works by searching backward for the opener and forward for the closer."
  (interactive "cDelete surrounding pair: ")
  (let* ((pairs '((?\( . ?\))
                  (?\[ . ?\])
                  (?{ . ?})
                  (?\" . ?\")
                  (?\' . ?\')
                  (?\` . ?\`)))
         (closer (or (alist-get char pairs)
                     (error "Unknown pair character: %c" char))))
    (save-excursion
      (let ((orig (point)))
        ;; Find and delete the opener
        (when (search-backward (char-to-string char) nil t)
          (delete-char 1)
          ;; Find and delete the closer (adjust for removed char)
          (goto-char (1- orig))
          (when (search-forward (char-to-string closer) nil t)
            (delete-char -1)))))))

(global-set-key (kbd "M-s-d") #'delete-surrounding-pair)

Now you can hit M-s-d ( to delete surrounding parens, M-s-d " for quotes, etc. It’s deliberately naive – no syntax awareness, no nesting support – so it won’t play well with delimiters inside strings or comments (it’ll happily match a paren in a comment if that’s what it finds first). But for quick, straightforward edits it gets the job done.

TIP: If you’re looking for something closer to the surround.vim experience in Emacs (without going full smartparens), check out surround.el. It’s a lightweight package (available on MELPA) that provides surround.vim-style operations – deleting, changing, and adding surrounding pairs – all through a single keymap. It supports both “inner” and “outer” text selection modes and works uniformly across file types, which makes it a nice middle ground between delete-pair and smartparens.

When to Use What

My current setup is:

• Lisp languages (Emacs Lisp, Clojure, Common Lisp, etc.): paredit, no contest.
• Everything else: electric-pair-mode for auto-pairing (I rarely need to unwrap something outside of Lisps)

I think surround.el will pair well with electric-pair-mode, but I discovered it only recently and I’ve yet to try it out in practice.

If you want a more powerful structural editing experience across all languages, smartparens is hard to beat. It’s just more than I personally need outside of Lisp.

Wrapping Up

One of the greatest aspects of Emacs is that we get to learn (or relearn) something about it every other day. Even after decades of daily use, there are always more commands lurking in the corners, patiently waiting to be discovered.

Now, if you’ll excuse me, I’m going to immediately forget about delete-pair again. Keep hacking!

Update: A reader pointed me to this Reddit thread with more tips on using delete-pair (including using it to change surrounding delimiters, surround.vim-style). Worth a read if you want to get more mileage out of it.

In the last article in the series, we talked about deleting files, which is scary and sad. In this article, I’m happy to change topics into creation territory as we learn how to create directories in the UNIXy way and the Emacs way.

Which way is better? I leave that up to you, but you should know both, because context matters, and there be times when you need one because the other one might not be available.

Remember, in your computer everything is a file, even directories are files that point to other files.

So let’s get into it.

Also, be sure to check out my DRM-free eBooks for your open source enjoyment (OSE):

• Emacs For Writers
• Git For Writers

mkdir new_directory
mkdir -p path/to/nested/directory

The post The Emacs Way: Create Directories appeared first on Chris Maiorana.

(subed-record-extract-all-approximately-matching-phrases
   sentences
   "/home/sacha/sync/recordings/2026-02-20-raphael.json"
   "/home/sacha/proj/french/analysis/virelangues/2026-02-20-raphael-script.vtt")

(my-lang-summarize-segments
 sentences
 '(("/home/sacha/proj/french/analysis/virelangues/2026-02-20-raphael-script.vtt" . "Feb 20")
 ;("~/sync/recordings/processed/2026-02-20-raphael-tongue-twisters.vtt" . "Feb 20")
        ("~/sync/recordings/processed/2026-02-22-virelangues-single.vtt" . "Feb 22")
        ("~/proj/french/recordings/2026-02-26-virelangues-script.vtt" . "Feb 26")
        ("~/proj/french/recordings/2026-02-27-virelangues-script.vtt" . "Feb 27")
        ("~/proj/french/recordings/2026-03-03-virelangues.vtt" . "Mar 3")
        ("/home/sacha/sync/recordings/processed/2026-03-03-raphael-reference-script.vtt" . "Mar 3")
        ("~/proj/french/analysis/virelangues/2026-03-06-raphael-script.vtt" . "Mar 6")
        ("~/proj/french/analysis/virelangues/2026-03-12-virelangues-script.vtt" . "Mar 12"))
 "clip"
 #'my-lang-subed-record-get-last-attempt
 #'my-lang-subed-record-cell-info
 t
 )

(my-subed-record-analyze-file-with-azure
 (subed-record-keep-last
  (subed-record-filter-skips
   (subed-parse-file
    "/home/sacha/proj/french/analysis/virelangues/2026-03-13-raphael-script.vtt")))
 "~/proj/french/analysis/virelangues-2026-03-13/2026-03-13-clip")

(defun my-lang-subed-record-cell-info (item file-index file sub)
  (let* ((sound-file (expand-file-name (format "%s-%s-%d.opus"
                                               prefix
                                               (my-transform-html-slugify item)
                                               (1+ file-index))))
         (score (car (split-string
                      (or
                       (subed-record-get-directive "#+SCORE" (elt sub 4)) "")
                      ";")))
         (note (replace-regexp-in-string
                (concat "^" (regexp-quote (cdr file))
                        "\\(: \\)?")
                ""
                (or (subed-record-get-directive "#+NOTE" (elt sub 4)) ""))))
    (when (or always-create (not (file-exists-p sound-file)))
      (subed-record-extract-audio-for-current-subtitle-to-file sound-file sub))
    (org-link-make-string
     (concat "audio:" sound-file "?icon=t"
             (format "&source=%s&source-start=%s" (car file) (elt sub 1))
             (format "&title=%s"
                     (url-hexify-string
                      (if (string= note "")
                          (cdr file)
                        (concat (cdr file) ": " note)))))
     (concat
      "▶️"
      (if score (format " %s" score) "")
      (if (string= note "") "" "*")))))

(defun my-lang-subed-record-get-last-attempt (item file)
  "Return the last subtitle matching ITEM in FILE."
  (car
   (last
    (seq-remove
     (lambda (o) (string-match "#\\+SKIP" (or (elt o 4) "")))
     (learn-lang-subed-record-collect-matching-subtitles
      item
      (list file)
      nil
      nil
      'my-subed-simplify)))))

(defun my-lang-summarize-segments (items files prefix attempt-fn cell-fn &optional always-create)
  (cons
   (append
    (seq-map 'cdr files)
    (list "Text"))
   (seq-map
    (lambda (item)
      (append
       (seq-map-indexed
        (lambda (file file-index)
          (let* ((sub (funcall attempt-fn item file)))
            (if sub
                (funcall cell-fn item file-index file sub)
              "")))
        files)
       (list item)))
    items)))

(defun my-subed-record-analyze-file-with-azure (subtitles prefix &optional always-create)
  (cons
   '("Gt" "Kk" "Az" "Me" "ID" "Comments" "All" "Acc" "Flu" "Comp" "Conf")
   (seq-map-indexed
    (lambda (sub i)
      (let ((sound-file (expand-file-name (format "%s-%02d.opus"
                                                  prefix
                                                  (1+ i))))
            (tts-services
             '(("gtts" . learn-lang-tts-gtts-say)
               ("kokoro" . learn-lang-tts-kokoro-fastapi-say)
               ("azure" . learn-lang-tts-azure-say)))
            tts-files
            (note (subed-record-get-directive "#+NOTE" (elt sub 4))))
        (when (or always-create (not (file-exists-p sound-file)))
          (subed-record-extract-audio-for-current-subtitle-to-file sound-file sub))
        (setq
         tts-files
         (mapcar
          (lambda (row)
            (let ((reference (format "%s-%s-%02d.opus" prefix (car row) (1+ i) )))
              (when (or always-create (not (file-exists-p reference)))
                (funcall (cdr row)
                         (subed-record-simplify (elt sub 3))
                         'sync
                         reference))
              (org-link-make-string
               (concat "audio:" reference "?icon=t&note=" (url-hexify-string (car row)))
               "👂🏼")))
          tts-services))
        (append
         tts-files
         (list
          (org-link-make-string
           (concat "audio:" sound-file "?icon=t"
                   (format "&source-start=%s" (elt sub 1))
                   (if (and note (not (string= note "")))
                       (format "&title=%s"
                               (url-hexify-string note))
                     ""))
           "▶️")
          (format "%d" (1+ i))
          (or note ""))
         (learn-lang-azure-subed-record-parse (elt sub 4))
         (list
          (elt sub 3)))))
    subtitles)))

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

Raw link: https://www.youtube.com/watch?v=M6ZHDJeG-dI

This is a holistic introduction to Emacs: how useful it is and how it champions free software. It is a modified version of the talk I did for the “FLOSS @ Oxford” event, organised by people at the University of Oxford. This is the page I wrote about that event: https://protesilaos.com/codelog/2026-03-12-my-emacs-talk-floss-oxford/.

Table of Contents

1. This is a holistic introduction to Emacs
2. Emacs as a capable text editor
3. Support for Unicode
4. Include several fonts on the same page
5. Emacs can display graphics alongside text
6. Emacs is an extensible text editor
7. Extending Emacs creates a community
8. The extensibility of Emacs happens live
9. My view without the “presentation mode”
10. Emacs puts you in control of your computing
11. Your control extends to all workflows
12. For an integrated computing environment
13. Many apps do not combine nicely
14. Emacs makes your workflow consistent
15. Integrated computing in practice
16. Emacs makes integration easier
17. Integration gives you emergent properties
18. This is plain text that works like a slideshow
19. Consistency facilitates productivity
20. Consistency remove the cognitive burden
21. The consistency of Emacs in action
22. Use Emacs Lisp to configure everything
23. Learning Emacs Lisp improves the experience
24. Emacs embodies software freedom
25. The freedom of Emacs helps with learning
26. Emacs is not only for programmers
27. You benefit from all the Emacs extensions
28. Some powerful extensions are built-in
29. The documentation culture of Emacs
30. Most packages have high quality manuals
31. Emacs has a steep learning curve
32. Do not skip the manuals
33. Adjust your expectations
34. Why it is worth learning how to use Emacs
35. The initial effort pays off long-term
36. Good luck and have fun!

Hello everyone! My name is Protesilaos, also known as “Prot”.

This presentation is a modified version of the talk I gave last night at the FLOSS @ Oxford event: https://ox.ogeer.org/event/computing-in-freedom-with-gnu-emacs-protesilaos-stavrou.

It was an event organised by people from the University of Oxford. I thank them for giving me the opportunity to participate in their programme.

I want to have this modified version here for people who do not read my website. They may not be aware that I talked at this Oxford event.

Having the video on this platform means that everyone can benefit from it.

1 This is a holistic introduction to Emacs

In this presentation I will talk to you about GNU Emacs, or simply, “Emacs”. Emacs is a program you run on your computer. I am using it right now for this presentation.

Emacs is free or libre software. It allows you to read all of its source code, to modify it, and to share it with your customisations. Thus you contribute to—and benefit from—a community of welcoming Emacs users.

I will tell you what all this means in practice and how you can improve your computing experience by switching to Emacs.

2 Emacs as a capable text editor

When you first start using Emacs, it feels like a regular text editor program.

You move the cursor around and edit text. Nothing obviously impressive out-of-the-box.

As a text editor, Emacs is highly capable. It has all sorts of keyboard shortcuts that let you efficiently operate on text.

You can control Emacs without relying on the mouse, if you want.

3 Support for Unicode

Emacs supports the Unicode standard, which is essential for inclusivity of peoples.

The world’s scripts can be expressed in Emacs. I am a native Greek speaker.

I can use functionality that is built into Emacs to switch to the Greek alphabet in order to write something, such as to say «καλησπέρα», which means “good evening”.

I can even spell out “Dao De Jing” (道德经), which is the title of a book from ancient China.

Plus emoji: 🦚🦬🐉.

4 Include several fonts on the same page

The multitude of scripts can be present in the same document.

This is an advantage for multilingual people like myself or those who do research that involves many natural languages.

Emacs can combine several fonts in the same page as well as different colours.

Each fonts can have its own attributes, such as for its relative size and typographic intensity.

Same idea for colours.

On my screen right now, I am already combining two different font styles: that of the heading and the body of the text.

5 Emacs can display graphics alongside text

Emacs does not limit you to a text-only interface. It can also display images and PDF documents. Below I have a link to an image file. I will now type a keyboard shortcut to reveal this image. And I will do it again to hide it.

This, by the way, is a spot somewhere in my mountains.

6 Emacs is an extensible text editor

Although you can benefit from using Emacs as a generic text editor, what really appeals to people like me is the option to extend Emacs.

“Extend” here means to introduce new functionality; functionality that is not available in the default program you install on your computer.

These extensions are written in the same programming language as most of Emacs. It is a programming language called “Emacs Lisp” or “Elisp”.

You can extend Emacs on your own, by writing some program in Elisp, or you can download an existing extension that the community has made available.

7 Extending Emacs creates a community

For example, when I create a new extension for Emacs, I publish it under the terms of a free software license—the same terms that Emacs uses.

Others can then download my extension and use it as they prefer. If they want, they can make their own modifications on top, which may introduce other extensions that I had not thought of in my original implementation.

And if those users follow my example, then I can also benefit from their additions once they publish them.

As such, there exists a community of enthusiastic users of Emacs who care about sharing their works with the rest of the world.

8 The extensibility of Emacs happens live

Users can extend Emacs by running some Emacs Lisp program. Such a program can be as short as a single line. Or it can be as long as it needs to be. It does not matter.

Users run the program and Emacs immediately does what the program renders possible.

For example, I am doing this presentation inside of Emacs. But Emacs does not have a “presentation mode” built into it. I thus developed my own extension which empowers me to do what I am doing right now.

Let me toggle off my presentation mode to show you what I mean.

9 My view without the “presentation mode”

Notice that the display has changed.My main font is monospaced now.

The headings are smaller than they were before: they are the same size as the rest of the text. There is no number next to the heading anymore.

Then, there is a bar at the bottom of my screen, with information about what I am working on. On the side, there are line numbers, indicating where my cursor is in this file. Plus, my current line is highlighted with a distinct background colour. Let me shift it up and down to illustrate this point.

All those elements are useful while I am programming. But they look distracting when I wish to focus on some portion of text. So, I just type the keyboard shortcut I have and—voilà!—I get the style I prefer.

10 Emacs puts you in control of your computing

You may wonder: why do I even need a customisable text editor?

The answer is about control. You are in charge of what you use and how you use it. You can piece together a workflow that works the way you prefer.

This presentation mode I toggled on and off earlier behaves exactly how I want. I decided which set of interface tweaks to apply. Another user may have a different preference in this regard.

For instance, they may like having line numbers on the side of the screen. There is no right or wrong answer. What matters is that Emacs gives us the means to do what makes sense to us.

11 Your control extends to all workflows

Now apply this principle to everything you can use Emacs for: this will generally be a text-centric project.

I run my agenda exclusively through Emacs.

I handle all my email correspondence with Emacs.

I do programming and I write prose, such as blog posts for my website and books or technical manuals.

For each of these, I know that Emacs will empower me to perform my tasks without arbitrary restrictions.

Emacs lets me use Elisp to modify how I do my emails, for instance, and how I present tasks in my custom agenda view.

12 For an integrated computing environment

Without Emacs, I would not be in a position to control my computing experience to the extent I do.

The reason is that I would be relying on many different applications. Each application has its own interface and design paradigms.

Each application is configured, if at all, in a way that is specific to it. Customisations in one application do not carry over to other applications.

And, if we consider the important implementation details, each application may configurable in its own programming language.

In other words, that is not an integrated computing experience.

13 Many apps do not combine nicely

To have the same degree of control that Emacs makes possible, I would have to hope that somehow all those disparate applications would conspire in my favour.

That is wishful thinking.

The reality is that piecing together many different applications is an exercise in frustration and the path to a life of ever-distracting context switching.

14 Emacs makes your workflow consistent

Having everything I need inside of Emacs ensures that things happen in a manner that is consistent.

All customisations are written in the same programming language, namely, Emacs Lisp.

What I define for one context, such as this “presentation mode”, can be used in another context.

For example, I can have this presentation style enabled when I read emails. Why?

Because it can make it more comfortable for me at a certain hour. And I can even automate this with conditional logic, so it happens on its own when I open a new email under certain circumstances.

15 Integrated computing in practice

When you work with many applications that do not play nicely together, you cannot do something that the developers have not envisaged.

For example, your email client likely does not have access to a “presentation mode”. Same for your other applications.

Similarly, your many applications will not necessarily know how to read and interpret the configurations you have in one application.

Suppose you define your favourite colour scheme for your email client. You take the time to consider the harmonies and use precise typography to your liking.

Now, you switch to your calendar application and none of that work carries over: you have to do it again, assuming it is even possible.

16 Emacs makes integration easier

Colours and styles may seem like relatively small issues. But they are indicative of something greater: disparate applications do not work together seamlessly.

Emacs does not have this problem. You define something for one context you have in mind and, eventually, it can be used in another context that initially you had not even thought of.

For example, in my Emacs I wrote a small function to quickly copy the “thing” at where the cursor is. This is useful when I do programming, as the “thing” can be an entire expression, like the definition of a function. But the “thing” may also be a link that I got in my email.

I had not thought of that use-case in advance. Yet it was trivial to have my function do what I need in this once unforeseen situation.

17 Integration gives you emergent properties

The integrated computing environment of Emacs is more than the sum of its parts.

This is because you can combine different pieces of functionality in ways that the original developer had not foresaw.

You do not simply have your writing, your email, your agenda, et cetera, in Emacs.

You have the functionality of one in tandem with the functionality of another. And you draw linkages between them as you see fit.

Consider once again this presentation I am now doing. What I have in front of me is the transcript of my talk. This is a plain text document, which I can edit live. Let me CAPITALISE THIS to illustrate the point.

18 This is plain text that works like a slideshow

I have made this file look a little bit like a series of slides.

Notice that if I scroll up and down, which I will do shortly, you only get the current section I am reading from: you do not have access to the rest of the document. I will scroll up and down now.

This is a feature known as “narrowing”. Let me “widen” the view and then try to scroll again. You will now be exposed to the rest of the text.

The original developer of this “narrowing” facility did not know how someone like me would make use of it.

I have it here for my presentation. Each heading becomes its own pseudo-slide. I have narrowing for my emails, when I want to read a portion of the text in a more focused way. It is all about how I choose to do my computing.

19 Consistency facilitates productivity

For many years before switching to Emacs, I did not enjoy using the computer.

I needed too much time to accomplish every single task.

I could never find any of my files in a timely fashion because there was no program that would enforce on my behalf a predictable file-naming scheme.

All my notes were eventually not retrievable. This made them useless. Data you save is only good if you can find what you are searching for.

My music collection was inconsistent because I needed special software to write the metadata… In short, I was not as productive as I would like to be.

And, above all, it was not fun.

20 Consistency remove the cognitive burden

Most of my work at the time was centred around the email client and a word processor.

The email client had its own subsystem for handling reminders for tasks. The format of those tasks was not interoperable with other programs.

I could not access the tasks with my favourite text editor. I thus had to use the clunky interface of the email client, which was never designed for task management—and was not configurable.

And then I had all the cognitively burdensome annoyances of my two applications looking quite different from each other.

My emails did not behave like my documents, which made it harder for me to flip between the two and continue writing. I would roll my eyes each time.

21 The consistency of Emacs in action

Emacs has elevated my computing experience.

I have been much more productive ever since I switched to it. Allow me to demonstrate a tiny bit of what I do each day.

I will temporarily exit the presentation mode in this window.

Then, in the bottom half of my screen, I will open my email client to read a message I got.

Once you follow my switch to the email client, I will hide the window that shows this presentation.

After that I will switch to my agenda to record a task and review what I have to do.

All this is done inside of Emacs. Time for action!

22 Use Emacs Lisp to configure everything

What I just demonstrated is a very small part of what I do every single day.

There is much more, though I cannot cover it all in this presentation.

The point, however, is the consistency of the experience; consistency throughout.

I have customised my email client by writing some Emacs Lisp code for it. I have done the same for the custom agenda I have. And much more.

Every time I work with Emacs Lisp, I acquire skills that are applicable outside the confines of the problem I am solving.

For example, by configuring email the way I want, I pick up programming skills that I can then apply to the design of my custom agenda.

23 Learning Emacs Lisp improves the experience

This is an investment that pays off more and more.

Emacs will adapt to match my evolving needs. Each new workflow I incorporate in my Emacs setup will thus benefit from all the knowledge and features I have accumulated.

I do not have to relearn everything because I am not switching to another application.

I do not have to throw away all the work I did all those years. It is here to stay.

I do not feel the pressure to try the new shiny app of the day. I did that many times and always regretted it. I lost my data and time in the process.

Because I am rooted in this stability of Emacs, I remain productive and efficient.

24 Emacs embodies software freedom

I mentioned earlier that Emacs is free or libre software. This means that you can read its source code, modify it, and share your changes with others.

Emacs has a license that gives users power. There is no corporation that can take Emacs away from us. It belongs to the community and we all tend to its wellness.

In the case of Emacs, software freedom is not just about the license. It informs how you use the program. Emacs makes such freedom an irriducible part of its functionality.

You can, at any moment, ask Emacs what does a keyboard shortcut actually do. What is the definition of a function. What is the value of a variable. And you may even access the source code to check for yourself.

I will demonstrate this right now.

25 The freedom of Emacs helps with learning

I actually learnt to program in Emacs Lisp by exercising this freedom.

I would tinker with Emacs and continuously check on its state. What does this do? Which function is called by that keyboard shortcut? How is a program able to determine if the file is not saved?

I wanted to learn how, for example, we move down a line. From there, I learnt that we can move down many lines at once.

I then figured that we can move down the lines and then also do something else, such as place the cursor at the end of the line and create a pulse effect to bring attention to it.

Not only did I learn how to configure Emacs, I even wrote tens of extensions for it. I have also authored a libre book titled “Emacs Lisp Elements”. This freedom is not theoretical. I did not have a background in programming, yet was empowered to act and to grow as a person.

26 Emacs is not only for programmers

Emacs is extended with Emacs Lisp. If you know how to program in that language, you can be extra opinionated and particular about the way Emacs facilitates your work.

But even without any expertise of this sort, you can still do much of what you like. Remember that I started using Emacs without a background in programming.

Emacs blurs the distinction between user and developer. Many of the developers actually start out as users like myself. They learn along the way and, eventually, they contribute to the development of Emacs.

I even have written code that is in core Emacs: my modus-themes as well as several other smaller patches.

27 You benefit from all the Emacs extensions

The Emacs community has developed a rich corpus of extensions. You do not need to invent anything right away in order to be productive.

We call these extensions “packages”, as they are distributed in a way that makes them easy to install and then use directly.

The Emacs program you will download on your computer ships with plenty of packages built-in.

Depending on your needs, you may not even have to install anything from what the community has to offer.

Though if you want a package, it is fairly easy to get it and run it on your system.

Emacs is not picky about how you should use it. You are empowered to be opinionated.

28 Some powerful extensions are built-in

For example, Emacs ships with a package called org or “Org mode”. At its core, this is a markup language. I am using it right now in this document.

Notice how lines that start with an asterisk function as headings. This is what the markup does.

Org lets you write documents, including books, handle your tasks, organise your agenda, and much more. It is a powerhouse.

There are so many things to discover in Emacs as well as the broader package ecosystem.

Emacs as a whole provides high quality documentation that explains everything.

29 The documentation culture of Emacs

When you install Emacs, you get with it plenty of technical manuals. There is also an interactive tutorial to help you make sense of the basics.

Furthermore, when you ask Emacs for help about the definition of a function or the value of a variable, you receive the documentation for the thing you are looking for.

The expectation for all contributions to the official Emacs program is that the code is well-documented and the manual is updated accordingly.

30 Most packages have high quality manuals

Core Emacs sets the standard of what good documentation looks like. Package developers follow this practice.

For example, my denote package has a manual that is over 7500 lines long. It exceeds 52000 words. In it users find detailed instructions as well as code snippets that they can copy and use outright. And this is not the exception. All my packages are like that, to the extent necessary. Most other developers do the same.

As a community, we have access to so much knowledge for free and in freedom. If we are committed enough, we can learn from others and thus become better ourselves. We do so in a spirit of sharing and caring. For me, specifically, all this was of great help. I am self-taught because I received all those great resources from the community. I consider it my duty to give back in kind.

31 Emacs has a steep learning curve

Because Emacs is extensible, there is practically no limit to what you can do with it. At least this is the case for all tasks that are text-heavy.

Emacs will just gracefully evolve to match your requirements, provided you can extend it on your own or with a relevant package.

The downside, however, is that it is not easy to become proficient in it. If you are committed, you can learn the basics within the first few days.

Though you will need to invest a few weeks or months to become skillful. It depends on how much effort you put into it, what sort of work you are doing, and what your background is.

I learnt the basics within a few days. I started writing my own Emacs Lisp within weeks. And within a year I had my modus-themes moved into core Emacs.

32 Do not skip the manuals

Several “starter kits” are available to help you get started. They set things up so that you do not need to discover everything at the outset.

The new version of Emacs (Emacs 31) will even come with a “newcomers theme”, which configures several settings in advance.

These can make the learning curve a bit smoother. For me, anything that improves the onboarding experiences is a plus.

Though I do not think that Emacs will ever become “plug and play”. This is due to its sheer depth and extensibility. It does so much that you still need to invest the time and effort into learning it.

However you start, the most reliable study involves the manuals. Those are written for the benefit of the user. Read them carefully.

33 Adjust your expectations

What I can say with confidence is that Emacs is not for tourists. You cannot switch to it with the expectation that you will have a good time right away.

No. That will not work. There simply is no shortcut to excellence.

I encourage you to take it one step at a time. Emacs will make you more productive, provided you are patient enough to unlock its virtually boundless potential.

Take it slow and be methodical. Rely on the official manual no matter your starting point. Read from it and gradually incorporate its insights into your workflow.

The community—myself included—has plenty of resources to complement that study. Blog posts, video tutorials, books… But do not skip the official manual. Learning it slowly means that you will become proficient faster than you otherwise would.

34 Why it is worth learning how to use Emacs

I already talked about the technical side of things with regard to the integrated computing environment. Now combine that with two facts:

1. Emacs is free software. This means that we as a community are its custodians.
2. GNU Emacs has been around since the 1980s. It will stay relevant for decades to come.

Emacs is not old, it is timeless. This is because it can be extended in a spirit of freedom.

Whatever new technology or idea we have as a collective, we can eventually bring it into Emacs.

This way, our integrated computing environment adapts with the times.

Thus Emacs remains ever-relevant.

35 The initial effort pays off long-term

Couched in those terms, the initial effort you will put into learning Emacs is actually not that much.

You have to maintain a longer-term view of this project.

If you are patient, Emacs will be one of the most reliable tools you will ever use throughout your life. And I say this as a handy man myself, someone who uses many tools for manual labour, having built the house I am in, among others.

I switched to Emacs in the summer of 2019. It is almost 7 years already. I see no reason not to use it for the next 7 years, if I can.

I will still want to write articles, do programming, maintain my agenda, and probably make presentations like this one.

36 Good luck and have fun!

Remember that you will not learn Emacs over the weekend. You are in it for the long-term. Take it slow and you will enjoy the experience.

This is all I have for you today folks. Thank you very much for your attention!

You can find this and everything else I publish on my website: https://protesilaos.com.

Speech synthesis has come a long way since I first tried out Emacspeak in 2002. Kokoro TTS and Piper offer more natural-sounding voices now, although the initial delay in loading the models and generating speech mean that they aren't quite ready to completely replace espeak, which is faster but more robotic. I've been using the Kokoro FastAPI through my own functions for working with various speech systems. I wanted to see if I could get Kokoro and other OpenAI-compatible text-to-speech services to work with either speechd-el or Emacspeak just in case I could take advantage of the rich functionality either provides for speech-synthesized Emacs use. speechd-el is easier to layer on top of an existing Emacs if you only want occasional speech, while emacspeak voice-enables many packages to an extent beyond speaking simply what's on the screen.

Speech synthesis is particularly helpful when I'm learning French because I can use it as a reference for what a paragraph or sentence should sound like. It's not perfect. Sometimes it uses liaisons that my tutor and Google Translate don't use. But it's a decent enough starting point. I also used it before to read out IRC mentions and compile notifications so that I could hear them even if I was paying attention to a different activity.

Here's a demonstration of speechd reading out the following lines using the code I've just uploaded to https://codeberg.org/sachac/speechd-ai:

• The quick brown fox jumps over the lazy dog.
• Now let's set the language to French so we can read the next line.
• Bonjour, je m'appelle Emacs.

There's about a 2-second delay between the command and the start of the audio for the sentence.

Note that speechd-speak-read-sentence fails in some cases where (forward-sentence 1) isn't the same place as (backward-sentence 1) (forward-sentence 1), which can happen when you're in an Org Mode list. I've submitted a patch upstream.

Aside from that, speechd-speak-set-language, speechd-speak-read-paragraph and speechd-speak-read-region are also useful commands. I think the latency makes this best-suited for reading paragraphs, or for shadowing sentences for language learning.

I'm still trying to figure out how to get speechd-speak to work as smoothly as I'd like. I think I've got it set up so that the server falls back to espeak for short texts so that it can handle words or characters better, and uses the specified server for longer ones. I'd like to get to the point where it can handle all the things that speechd usually does, like saying lines as I navigate through them or giving me feedback as I'm typing. Maybe it can use espeak for fast feedback character by character and word by word, and then use Kokoro TTS for the full sentence when I finish. Then it will be possible to use it to type things without looking at the screen.

After putting this together, I still find myself leaning towards my own functions because they make it easy to see the generated speech output to a file, which is handy for saving reference audio that I can play on my phone and for making replays almost instant. That could also be useful for pre-generating the next paragraph to make it flow more smoothly. Still, it was interesting making something that is compatible with existing protocols and libraries.

Posting it in case anyone else wants to use it as a starting point. The repository also contains the starting point for an Emacspeak-compatible speech server. See See speechd-ai/README.org for more details.

https://codeberg.org/sachac/speechd-ai

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

There is now an in-buffer replace feature in ollama-buddy, so now an ollama response can work directly on your text, streaming the replacement in real-time, and giving you a simple accept/reject choice!, I have also added an smerge diff inline if desired to show the differences and give the user the ability to accept or reject

Here is how it works : https://www.youtube.com/watch?v=Po7Wqpk0sqY

The feature is tucked away in the transient menu. Here’s the workflow:

1. Toggle it on via C-c O → Actions → W, or run M-x ollama-buddy-toggle-in-buffer-replace
2. A small ✎ indicator appears in your header line, confirming the mode is active
3. Select a region of text you want rewritten
4. Invoke a command from the role menu; for example, C-c o then pick your rewrite command
5. Watch as the AI streams the replacement directly into your buffer

It is also worth noting that each custom menu can be defined with a :destination option, for either in-buffer or chat, so the global in-buffer replace doesn’t need to be selected, and the custom transient menu can be tailored for each command. For example, in the default custom menu, refactor code and proofread have the destination of in-buffer set, but actions like git commit message or describe code will fall back to the global option, which by default is chat, which is probably what you would want for these options.

During streaming, you’ll see a dimmed, italic [Rewriting...] placeholder where your selection was. The new text then flows in with a highlight overlay.

Once the stream finishes, you’re dropped into a minor mode with two options:

C-c C-c → accept the changes (keep new text, clear highlighting)
C-c C-k → reject and restore your original text

The mode line helpfully shows [Rewrite?] while you’re deciding. It’s a bit like ediff but for AI-generated changes and uses smerge-mode.

What if the AI starts going off the rails halfway through? No problem. Press C-c C-k at any point during streaming and the network process stops immediately, restoring your original selection. No waiting for it to finish rambling!

Press C-c d and the original text gets inserted below the new text in the same buffer. Word-level differences are highlighted using smerge-refine-regions, so you can see exactly what changed at a glance.

Green overlays mark added or modified words. Red strikethrough overlays show what was removed. It’s proper granular diffing, not just a before-and-after comparison.

This workflow is particularly useful for:

• Refactoring code blocks you’ve already written
• Rephrasing documentation or prose that feels clunky
• Adjusting tone without losing your core message
• Quick grammar and style improvements

It’s less about “write this for me from scratch” and more “help me iterate on what I’ve already got.”

For best results, I’ve found that smaller, focused selections work better than trying to rewrite entire files in one go. The AI has more context to work with, and you can make more granular decisions about what to keep.

Next up is probably some more polish on the diff highlighting, or perhaps exploring how this could work with multi-file projects. But for now, again I think this implementation is good enough.

Earlier today, at 20:00 Europe/Athens time, I provided an introduction to Emacs at the event FLOSS @ Oxford: https://ox.ogeer.org/event/computing-in-freedom-with-gnu-emacs-protesilaos-stavrou.

I had written the transcript ahead of time to make my presentation more accessible. The event was held live as a Jitsi call. There were questions from participants, which I answered. A recording of the event will be available before the end of this week. I will update this article to include a link to the video.

UPDATE 2026-03-16 07:49 +0200: The video is here: https://ogeer.org/ox/rec/emacs/.

Below is the text of my talk. It is titled “Computing in freedom with GNU Emacs”. Note that some parts of my presentation only make sense in the video format, though I tried to describe in the transcript what I was demonstrating.

Table of Contents

1. Emacs as a capable text editor
2. Emacs can display graphics alongside text
3. Emacs is an extensible text editor
4. The extensibility of Emacs happens live
5. Emacs puts you in control of your computing
6. The promise of an integrated computing environment
7. The integrated computing environment in practice
8. Integration gives you emergent properties
9. Consistency facilitates productivity
10. The consistency of Emacs in action
11. Use Emacs Lisp to configure everything
12. Emacs is the embodiment of software freedom
13. You do not need to be a programmer to use Emacs
14. The documentation culture of Emacs
15. Emacs has a steep learning curve
16. Why it is worth learning how to use Emacs
17. Good luck and have fun!

Hello everyone! My name is Protesilaos, also known as “Prot”. I am joining you from the mountains of Cyprus. Cyprus is an island in the Eastern Mediterranean Sea.

In this presentation I will talk to you about GNU Emacs, or simply, “Emacs”. Emacs is a program you run on your computer. I am using it right now for this presentation.

Emacs is free or libre software. It allows you to read all of its source code, to modify it, and to share it with your customisations. Thus you contribute to—and benefit from—a community of welcoming Emacs users.

I will tell you what all this means in practice and how you can improve your computing experience by switching to Emacs.

Emacs as a capable text editor

When you first start using Emacs, it feels like a regular text editor program. You move the cursor around and edit text. Nothing obviously impressive out-of-the-box. As a text editor, Emacs is highly capable. It has all sorts of keyboard shortcuts that let you efficiently operate on text. You can control Emacs without relying on the mouse, if you want.

Emacs supports the Unicode standard, which is essential for inclusivity of peoples. The world’s scripts can be expressed in Emacs. I am a native Greek speaker. I can use functionality that is built into Emacs to switch to the Greek alphabet in order to write something, such as to say «καλησπέρα», which means “good evening”. I can even spell out “Dao De Jing” (道德经), which is the title of a book from ancient China. Plus emoji: 🙃.

The multitude of scripts can be present in the same document. This is an advantage for multilingual people or those who do research that involves many natural languages.

Emacs can combine several fonts in the same page as well as different colours. Each fonts can have its own attributes, such as for its relative size and typographic intensity. Same idea for colours. On my screen right now, I am already combining two different font styles: that of the heading and the body of the text.

Emacs can display graphics alongside text

Emacs does not limit you to a text-only interface. It can also display images and PDF documents. Below I have a link to an image file. I will now type a keyboard shortcut to reveal this image. And I will do it again to hide it.

[Here is an image that I do not need to reproduce on my website: the specific image does not matter]

This, by the way, is a spot somewhere in my mountains.

Emacs is an extensible text editor

Although you can benefit from using Emacs as a generic text editor, what really appeals to people like me is the option to extend Emacs. “Extend” here means to introduce new functionality; functionality that is not available in the default program you install on your computer.

These extensions are written in the same programming language as most of Emacs. It is a programming language called “Emacs Lisp” or “Elisp”. You can extend Emacs on your own, by writing some program in Elisp, or you can download an existing extension that the community has made available.

For example, when I create a new extension for Emacs, I publish it under the terms of a free software license—the same terms that Emacs uses. Others can then download my extension and use it as they prefer. If they want, they can make their own modifications on top, which may introduce other extensions that I had not thought of in my original implementation. And if those users follow my example, then I can also benefit from their additions once they publish them.

As such, there exists a community of enthusiastic users of Emacs who care about sharing their works with the rest of the world.

The extensibility of Emacs happens live

Users can extend Emacs by running some Emacs Lisp program. Such a program can be as small as a single line. Or it can be as long as it needs to be. It does not matter. Users run the program and Emacs immediately does what the program renders possible.

For example, I am doing this presentation inside of Emacs. But Emacs does not have a “presentation mode” built into it. I thus developed my own extension which empowers me to do what I am doing right now. Let me toggle off my presentation mode to show you what I mean.

Notice that the display has changed. My main font is monospaced now. The headings are smaller than they were before: they are the same size as the rest of the text. There is no number next to the heading anymore. Then, there is a bar at the bottom of my screen, with information about what I am working on. On the side, there are line numbers, indicating where my cursor is in this file. Plus, my current line is highlighted with a distinct background colour. Let me shift it up and down to illustrate this point.

All those elements are useful while I am programming. But they look distracting when I wish to focus on some portion of text. So, I just type the keyboard shortcut I have and—voilà!—I get the style I prefer.

Emacs puts you in control of your computing

You may wonder: why do I even need a customisable text editor? The answer is about control. You are in charge of what you use and how you use it. You can piece together a workflow that works the way you prefer.

This presentation mode I toggled on and off earlier behaves exactly how I want. I decided which set of interface tweaks to apply. Another user may have a different preference in this regard. For instance, they may like having line numbers on the side of the screen. There is no right or wrong answer. What matters is that Emacs gives us the means to do what makes sense to us.

Now apply this principle to everything you can use Emacs for: this will generally be a text-centric project. I run my agenda exclusively through Emacs. I handle all my email correspondence with Emacs. I do programming and I write prose, such as blog posts for my website and books or technical manuals.

For each of these, I know that Emacs will empower me to perform my tasks without arbitrary restrictions. Emacs lets me use Elisp to modify how I do my emails, for instance, and how I present tasks in my custom agenda view.

The promise of an integrated computing environment

Without Emacs, I would not be in a position to control my computing experience to the extent I do. The reason is that I would be relying on many different applications. Each application has its own interface and design paradigms. Each application is configured, if at all, in a way that is specific to it. Customisations in one application do not carry over to other applications. And, if we consider the important implementation details, each application may configurable in its own programming language.

In other words, that is not an integrated computing experience. To have the same degree of control that Emacs makes possible, I would have to hope that somehow all those disparate applications would conspire in my favour. That is wishful thinking. The reality is that piecing together many different applications is an exercise in frustration and the path to a life of ever-distracting context switching.

Having everything I need inside of Emacs ensures that things happen in a manner that is consistent. All customisations are written in the same programming language, namely, Emacs Lisp. What I define for one context, such as this “presentation mode”, can be used in another context. For example, I can have this presentation style enabled when I read emails. Why? Because it can make it more comfortable for me at a certain hour. And I can even automate this, so it happens on its own when I open a new email.

The integrated computing environment in practice

When you work with many applications that do not play nicely together, you cannot do something that the developers have not envisaged. For example, your email client likely does not have access to a “presentation mode”. Same for your other applications.

Similarly, your many applications will not necessarily know how to read and interpret the configurations you have in one application. Suppose you define your favourite colour scheme for your email client. You take the time to consider the harmonies and use precise typography to your liking. Now, you switch to your calendar application and none of that work carries over: you have to do it again, assuming it is even possible.

Colours and styles may seem like relatively small issues. But they are indicative of something greater: disparate applications do not work together seamlessly.

Emacs does not have this problem. You define something for one context you have in mind and, eventually, it can be used in another context that initially you had not even thought of. For example, in my Emacs I wrote a small function to quickly copy the “thing” at where the cursor is. This is useful when I do programming, as the “thing” can be an entire expression, like the definition of a function. But the “thing” may also be a link that I got in my email. I had not thought of that use-case in advance.

Integration gives you emergent properties

The integrated computing environment of Emacs is more than the sum of its parts. This is because you can combine different pieces of functionality in ways that the original developer had not foresaw. You do not simply have your writing, your email, your agenda, et cetera, in Emacs. You have the functionality of one in tandem with the functionality of another. And you draw linkages between them as you see fit.

Consider once again this presentation I am now doing. What I have in front of me is the transcript of my talk. This is a plain text document, which I can edit live. Let me CAPITALISE THIS to illustrate the point. But I have made this file look a little bit like a series of slides. Notice that if I scroll up and down, which I will do now, you only get the current section I am reading from: you do not have access to the rest of the document. This is a feature known as “narrowing”. Let me “widen” the view and then try to scroll again. You will now be exposed to the rest of the text.

The original developer of this “narrowing” facility did not know how someone like me would make use of it. I have it here for my presentation. Each heading becomes its own pseudo-slide. I have narrowing for my emails, when I want to read a portion of the text in a more focused way. It is all about how I choose to do my computing.

Consistency facilitates productivity

For many years before switching to Emacs, I did not enjoy using the computer. I needed too much time to accomplish every single task. I could never find any of my files in a timely fashion because there was no program that would enforce on my behalf a predictable file-naming scheme.

All my notes were eventually not retrievable. My music collection was inconsistent because I needed special software to write the metadata… In short, I was not as productive as I would like to be. And, above all, it was not fun.

Most of my work at the time was centred around the email client and a word processor. The email client had its own subsystem for handling reminders for tasks. The format of those tasks was not interoperable with other programs. I could not access it with my favourite text editor. I thus had to use the clunky interface of the email client, which was never designed for task management—and was not configurable.

And then I had all the cognitively burdensome annoyances of my two applications looking quite different from each other. My emails did not behave like my documents, which made it harder for me to flip between the two and continue writing.

The consistency of Emacs in action

Emacs has elevated my computing experience. I have been much more productive ever since I switched to it. Allow me to demonstrate a tiny bit of what I do each day. I will temporarily exit the presentation mode in this window. Then, in the bottom half of my screen, I will open my email client to read a message I got. After that I will switch to my agenda to record a task and review what I have to do. All this is done inside of Emacs. Time for action!

Use Emacs Lisp to configure everything

What I just demonstrated is a very small part of what I do every single day. There is much more, though I cannot cover it all in this presentation. The point, however, is the consistency of the experience; consistency throughout.

I have customised my email client by writing some Emacs Lisp code for it. I have done the same for the custom agenda I have. And much more.

Every time I work with Emacs Lisp, I acquire skills that are applicable outside the confines of the problem I am solving. For example, by configuring email the way I want, I pick up programming skills that I can then apply to the design of my custom agenda.

This is an investment that pays off more and more. Emacs will grow or shrink to match my evolving needs. Each new workflow I incorporate in my Emacs setup will thus benefit from all the knowledge and features I have accumulated.

I do not have to relearn everything. I do not have to throw away all the work I did. It is here to stay. I do not feel the pressure to try the new shiny app of the day. And, because I am rooted in this stability, I remain productive and efficient.

Emacs is the embodiment of software freedom

I mentioned earlier that Emacs is free or libre software. This means that you can read its source code, modify it, and share your changes with others. Emacs has a license that gives users power. There is no corporation that can take Emacs away from us. It belongs to the community and we all tend to its wellness.

Software freedom is not just about the license. Emacs makes such freedom an irriducible part of its functionality. You can, at any moment, ask Emacs what does a keyboard shortcut actually do. What is the definition of a function. What is the value of a variable. And you may even access the source code to check for yourself.

I actually learnt to program in Emacs Lisp by exercising this freedom. I would tinker with Emacs and continuously check on its state. I wanted to learn how, for example, we move down a line. From there, I learnt that we can move down many lines at once. I then figured that we can move down the lines and then also do something else, such as place the cursor at the end of the line and create a pulse effect to bring attention to it.

Not only did I learn how to configure Emacs, I even wrote tens of extensions for it. I have also authored a libre book titled “Emacs Lisp Elements”. This freedom is not theoretical. I did not have a background in programming, yet was empowered to act.

You do not need to be a programmer to use Emacs

Emacs is extended with Emacs Lisp. If you know how to program in that language, you can be extra opinionated and particular about the way Emacs facilitates your work.

But even without any expertise of this sort, you can still do much of what you like. This is because the Emacs community has developed a rich corpus of extensions. We call these extensions “packages”, as they are distributed in a way that makes them easy to install and then use directly.

The Emacs program you will download on your computer ships with plenty of packages built-in. Depending on your needs, you may not even have to install anything from what the community has to offer.

For example, Emacs ships with a package called org or “Org mode”. At its core, this is a markup language. I am using it right now in this document. Notice how lines that start with an asterisk function as headings. This is what the markup does. Org lets you write documents, including books, handle your tasks, organise your agenda, and much more. It is a powerhouse. There are so many things to discover. Emacs provides high quality documentation that explains everything.

The documentation culture of Emacs

When you install Emacs, you get with it plenty of technical manuals. There is also an interactive tutorial to help you make sense of the basics. Furthermore, when you ask Emacs for help about the definition of a function or the value of a variable, you receive the documentation for the thing you are looking for.

The expectation for all contributions to the official Emacs program is that the code is well-documented and the manual is updated accordingly.

This is true also for packages that the community develops. For example, my denote package has a manual that is over 7500 lines long. It exceeds 52000 words. In it users find detailed instructions as well as code snippets that they can copy and use outright. And this is not the exception. All my packages are like that, to the extent necessary. Most other developers do the same.

As a community, we have access to so much knowledge for free and in freedom. If we are committed enough, we can learn from others and thus become better ourselves. We do so in a spirit of sharing and caring. For me, specifically, all this was of great help. I am self-taught because I received all those great resources from the community. I consider it my duty to give back in kind.

Emacs has a steep learning curve

Because Emacs is extensible, there is practically no limit to what you can do with it. At least this is the case for all tasks that are text-heavy. Emacs will just gracefully evolve to match your requirements, provided you know how to extend it.

The downside, however, is that it is not easy to become proficient in it. If you are committed, you can learn the basics within the first few days. Though you will need to invest a few weeks or months to become skillful. It depends on how much effort you put into it.

What I can say with confidence is that Emacs is not for tourists. You cannot switch to it with the expectation that you will have a good time right away. No. That will not work. There simply is no shortcut to excellence.

I thus encourage you to adjust your expectations. Emacs will make you more productive, provided you are patient enough to unlock its virtually boundless potential. Take it slow and be methodical. Rely on the official manual. Read from it and gradually incorporate its insights into your workflow. The community has plenty of resources to complement that study. But do not skip the official manual. Learning it slowly means that you will become proficient faster than you otherwise would.

Why it is worth learning how to use Emacs

I already talked about the technical side of things with regard to the integrated computing environment. Now combine that with two facts:

1. Emacs is free software. This means that we as a community are its custodians.
2. GNU Emacs has been around since the 1980s. It will stay relevant for decades to come.

Emacs is not old, it is timeless. This is because it can be extended in a spirit of freedom. Whatever new technology or idea we have as a collective, we can eventually bring it into Emacs. This way, our integrated computing environment adapts with the times.

Couched in those terms, the initial effort you will put into learning Emacs is actually not that much. You have to maintain a longer-term view of this project. If are patient, Emacs will be one of the most reliable tools you will ever use throughout your life. And I say this as a handy man myself, having built the house I am in, among others.

I switched to Emacs in the summer of 2019. It is almost 7 years already. I see no reason not to use it for the next 7 years, if I can. I will still want to write articles, do programming, maintain my agenda, and probably make presentations like this one.

Good luck and have fun!

Remember that you will not learn Emacs over the weekend. You are in it for the long-term. Take it slow and you will enjoy the experience.

This is all I have for you today folks. Thank you very much for your attention!

We got quite a few agent-shell additions since the last post, so let's go through the highlights as of v0.47.1.

What's agent-shell?

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

Your employer can make a difference

agent-shell has been attracting quite a few users. Many of you are working in tech where employers are happily paying for IDE subscriptions and LLM tokens to improve productivity. If you are using agent-shell for work, consider getting your employer to give back by sponsoring the project.

I also know many of you work at AI companies offering paid agents like Claude Code, Copilot, Gemini, Codex, etc. all supported by agent-shell. Please nudge your employers to help fund projects like agent-shell, which are making their services available to more users.

So what's new?

claude-code-acp renamed to claude-agent-acp [Action Required]

Let's get this one out of the way, as it needs actioning. Both the npm package and the CLI agent have been renamed from claude-code-acp to claude-agent-acp (to align with Anthropic's branding guidelines). If you're using Claude Code, you'll need to update:

npm remove -g @zed-industries/claude-code-acp
npm install -g @zed-industries/claude-agent-acp

If you had customized agent-shell-anthropic-claude-acp-command, update it to point to claude-agent-acp.

New agents supported

• Auggie (#179 by @Pacane).
• Cline.
• Factory Droid (#178 by @ag91).
• GitHub Copilot.
• Kiro CLI (#351 by @zmjones).
• Mistral Vibe.
• Pi (#232 by @conornash)

Bootstrapped sessions (experimental)

This was a biggie. How sessions are loaded is now configurable via agent-shell-session-strategy. When set to 'new, starting a new shell delivers a fully bootstrapped session before presenting you with the shell prompt. This means the ACP handshake, authentication, and session creation all happen upfront.

You can enable this flow with:

(setq agent-shell-session-strategy 'new)

What's the benefit? Bootstrapped sessions enable changing models and session modes (Planning, Don't ask, Skip permissions, etc…) before submitting your first prompt.

For the time being, the existing (deferred) behaviour is still offered via 'new-deferred. Just set as follows:

(setq agent-shell-session-strategy 'new-deferred)

Session resume (experimental)

Probably the most requested feature and also facilitated by the bootstrapping changes. agent-shell-session-strategy also unlocks session resume. Set it to 'prompt and every time either M-x agent-shell-new-shell or C-u M-x agent-shell are invoked, you'll be offered to resume previous sessions or start a new one.

(setq agent-shell-session-strategy 'prompt)

Alternatively, you can set to 'latest to always resume the most recent session in current project.

Under the hood, there are two ways to pick up from previous session: session/resume (lightweight, no message replay) and session/load (full history replay). By default, agent-shell prefers resuming (controlled by agent-shell-prefer-session-resume). Please favor resuming for the time being as loading has more edge cases to sort out still.

Note: Both resuming and loading sessions are agent-dependent. Some agents may not yet support either, especially as the features aren't yet considered stable in Agent Client Protocol (see session/list spec).

This feature was a collaboration between @farra, @travisjeffery, and myself.

Clipboard images

You can now use agent-shell-send-clipboard-image (#285 by @dangom) to send images straight from your clipboard into agent-shell. Clipboard images are saved to .agent-shell/screenshots in your project root and inserted into the shell buffer as context.

Note: You'll need either pngpaste or xclip installed on your system for the feature to automatically kick in.

In addition, we now have agent-shell-yank-dwim: if the clipboard has an image, it pastes it as context. Otherwise, it yanks text as usual. In other words, copy an image anywhere to your system's clipboard and paste/yank into the buffer as usual (typically via C-y).

Status display + tool calls

Status labels and tool call titles rendering got some improvements. Status reporting is generally more compact, redundant text is dropped from tool call titles, and tool status/kind shortening has been consolidated.

Image rendering

agent-shell now renders images inline. When agents output images (charts, diagrams, screenshots, etc.), they display directly in the shell buffer. You may need to nudge the agent to output image paths in the expected format so agent-shell can pick up.

Markdown images:

![alt text](/path/to/image.png)

Any of the following in a line of their own are supported also:

/path/to/image.png

file:///path/to/image.png

./output/chart.png
~/screenshots/demo.png

Recognized image formats depend on what your Emacs was built with (typically png, jpeg, gif, svg, webp, tiff, etc. via image-file-name-extensions).

Emacs skills

While on the topic of image rendering, this works particularly well when coupled with charting agent skills. I shared some of these over at emacs-skills, demoed in episode 13 of the Bending Emacs series.

Table rendering

Tables are now rendered using overlays (#17 by @ewilderj).

Usage tracking

Tracking usage now possible (#270 by @Lenbok):

• A color-coded context usage indicator in the header (green -> yellow -> red as context fills up), enabled by default via agent-shell-show-context-usage-indicator.
• M-x agent-shell-show-usage to check token counts, context window usage, and cost in the minibuffer.r- An optional end-of-turn usage summary can be enabled via (setq agent-shell-show-usage-at-turn-end t).

Git worktree shell

If keen to run multiple agents on the same repo without stepping on each other's work, M-x agent-shell-new-worktree-shell facilitates this via git worktrees (#255 by @nhojb).

Send context to…

You can now send context to a specific shell using agent-shell-send-file-to, agent-shell-send-region-to, agent-shell-send-clipboard-image-to. and agent-shell-send-screenshot-to. These prompt you to pick a target shell.

Both M-x agent-shell and agent-shell-send-dwim are now prefix-aware. C-u forces a new shell, while C-u C-u prompts you to pick a target shell.

Compose buffer improvements

Compose buffers now support file (via @) and command (via /) completions. It is now also possible to browse previous pages via C-c C-p and come back to your prompt draft.

There's also prompt history navigation/insertion when composing prompts via M-p (previous), M-n (next), and M-r (search).

Bringing context into viewport compose buffers is now more robust. For example, carrying context into a new viewport compose buffer is now supported (#383 by @liaowang11).

Viewport improvements

While viewport interaction was introduced in the previous post, it is now my preferred way of interacting with agent-shell. You can enable via (setq agent-shell-prefer-viewport-interaction t). In any case, viewport buffers got a handful of quality-of-life improvements.

Single key replies without needing to open a compose/reply buffer:

• y sends "yes" (handy for quickly answering agent questions).
• 1-9 sends digits (handy for quickly choosing options).
• m sends "more" (handy for requesting more of the same kind of data).
• a sends "again" (handy for requesting to carry out instructions again).

Customizable context sources

agent-shell-context-sources lets you configure which DWIM context sources are considered by M-x agent-shell, agent-shell-send-dwim, and compose buffers. You can control the order sources are checked and add custom functions. Defaults to files, region, error, and line.

I'm always on the lookout for some DWIM goodness. If you add your own context function, I'd love to hear about it.

Flycheck support

While on the topic of context sources, in addition to picking up flymake errors at point, flycheck errors are now automatically recognized (#219 by @Lenbok).

Diff improvements

Diff buffers got some love too, now with syntax highlighting (#198 by @Azkae). There's also a new agent-shell-diff-mode-map for customizing diff keybindings, which avoid inheriting unsupported features from the parent mode. You can also press f to open the modified file from a diff buffer.

Additionally, you can now press C-c C-c from an agent-shell-diff buffer to reject all changes (same binding as the shell itself).

Event subscriptions

You can now programmatically subscribe to agent-shell events like initialization steps, tool call updates, file writes, permission responses, permission requests, and turn completions. This opens the door for building integrations on top of agent-shell.

(agent-shell-subscribe-to
 :shell-buffer (current-buffer)
 :event 'file-write
 :on-event (lambda (event)
             (message "File written: %s"
                      (alist-get :path (alist-get :data event)))))

Permission UX improvements

Permission dialogs got a few improvements. Amongst them, automatic navigation to the next pending dialog and also making executed commands more prominent for some agents.

Permission responder function

You can now programmatically respond to permission requests via agent-shell-permission-responder-function. A built-in agent-shell-permission-allow-always handler is provided to auto-approve everything (use with caution):

(setq agent-shell-permission-responder-function #'agent-shell-permission-allow-always)

Claude Code OAuth token support

OAuth token now supported for Claude Code (#339 by @chemtov).

Transcript improvements

Markdown transcripts generation needed love. Thank you @Idorobots and @systemfreund for the improvements (#374, #325, and #326).

Session ID display

With (setq agent-shell-show-session-id t), session IDs are now displayed in header as well as session lists (#363 by @Cy6erBr4in).

Custom CWD function

agent-shell-cwd-function now enables customizing how agent-shell determines the working directory sent to agents.

Configurable dot-subdir location

agent-shell-dot-subdir-function now lets you customize where agent-shell keeps per-project files (#378 by @zackattackz).

Lambda MCP servers

agent-shell-mcp-servers now accept lambda functions too (#237 by @matthewbauer). Useful for setups like claude-code-ide using dynamic MCP details.

Buffer name format

agent-shell-buffer-name-format now makes buffer naming configurable. Choose between the default title case ("Claude Code Agent @ My Project"), kebab-case ("claude-code-agent @ my-project"), or provide your own function (#256 by @nhojb).

Inhibit minor modes during writes

agent-shell-write-inhibit-minor-modes lets you temporarily disable modes (like auto-formatting entire file) when agents write files (#224 by @ultronozm).

File autocompletion performance

File autocompletion is now more performant for larger repositories (#262 by @perfectayush).

Container modeline indicator

When running shells inside a container, a [C] indicator now shows up in the modeline (#250 by @ElleNajt).

Graphical header improvements

Graphical header rendering is more robust now (#275 by @nhojb).

Busy throbber display options

The busy/working indicator now offers multiple visual styles, customizable via agent-shell-busy-indicator-frames (#280 by @Lenbok).

New related packages

• agent-shell-to-go: Interact with agent-shell sessions from your mobile or any other device via Slack (by @ElleNajt).
• meta-agent-shell: Multi-agent coordination system for agent-shell with inter-agent communication, task tracking, and project-level dispatching (by @ElleNajt).
• agent-shell-workspace: Dedicated tab-bar workspace for managing multiple agent-shell sessions (by @gveres).

Pull requests

Thank you to all contributors for these improvements!

• #159: Improve Mistral Vibe documentation (@KaiHa)
• #162: Fix agent-shell-help-menu binding (@jinnovation)
• #164: Fix nil-check semantics in when-let (@jinnovation)
• #166: Use project-name for buffer names (@catern)
• #169: Resolve @mentioned paths in devcontainers (@fritzgrabo)
• #173: Fix when-let binding issue (@byronclark)
• #178: Add Factory Droid capability (@ag91)
• #179: Add Auggie support (@Pacane)
• #185: Update OpenCode logo (@bps)
• #186: Use context in viewport mode (@byronclark)
• #193: Handle user_message_chunk session update type (@Lenbok)
• #196: Fix agent names when config icons are off (@budevg)
• #197: Function-based container command runner (@rpoisel)
• #198: Syntax highlighting in diffs (@Azkae)
• #199: Fix reply in viewport mode (@byronclark)
• #200: Prevent context from own agent-shell buffer (@juboba)
• #204: Terminal-mode status labels (@whhone)
• #206: Add Evil section to README (@juboba)
• #208: Theme-aware status label color (@whhone)
• #209: Add missing image require (@timvisher)
• #212: Simplify language detection (@necaris)
• #213: Improve file and command completion (@necaris)
• #214: Fix auto-insert variable declaration (@ultronozm)
• #219: Flycheck error context support (@Lenbok)
• #224: Inhibit minor modes during file writes (@ultronozm)
• #226: Deduplicate file link (@bixuanzju)
• #232: Add Pi coding agent (@conornash)
• #235: Fix empty list normalizer (@ROCKTAKEY)
• #237: Lambda MCP servers (@matthewbauer)
• #240: Fix viewport shell buffer association (@Rutherther)
• #245: Fix :tool-calls state maintenance (@vermiculus)
• #246: Respect viewport visits for buffer ordering (@Rutherther)
• #249: Fix tool call title duplication (@ElleNajt)
• #250: Container modeline indicator (@ElleNajt)
• #252: Document C-c C-c to send (@HIRANO-Satoshi)
• #255: Git worktree shell (@nhojb)
• #256: Buffer name format customization (@nhojb)
• #257: Fix kebab-case project name (@nhojb)
• #262: File autocompletion speedup (@perfectayush)
• #266: Guard permission title rendering (@budevg)
• #269: Add missing paren (@Rutherther)
• #270: Session usage tracking (@Lenbok)
• #272: Update Copilot ASCII art (@ewilderj)
• #275: Graphical header improvements (@nhojb)
• #279: Add agent-shell-send-dwim to transient (@matthewbauer)
• #280: Busy throbber options (@Lenbok)
• #285: Clipboard image pasting (@dangom)
• #289: Session list/load/resume (@farra, @travisjeffery)
• #291: Normalize tool call commands (@ultronozm)
• #292: Strip text properties from copied text (@ultronozm)
• #293: Restore usage indicator color (@Lenbok)
• #295: Handle tools without a command (@byronclark)
• #296: Handle nil tool-call command (@genegoykhman)
• #299: claude-code-acp -> claude-agent-acp rename (@byronclark)
• #312: Function-valued model ID (@lgfang)
• #316: Fix diff syntax highlighting (@Azkae)
• #318: Tool call parameters in transcripts (@systemfreund)
• #319: Fix terminal Emacs font crash (@eddof13)
• #325: Log agent thoughts in transcript (@Idorobots)
• #326: Fix nested backtick fences in transcript (@systemfreund)
• #328: Switch modes in agent-shell-diff (@wmedrano)
• #329: Fix tests (@timvisher-dd)
• #313: Bring "Start a new session" to the top (@catern)
• #335: Fix plan from request_permission (@Azkae)
• #339: OAuth token support for Anthropic (@chemtov)
• #350: Prepare devcontainer package extraction (@fritzgrabo)
• #351: Add Kiro CLI ACP support (@zmjones)
• #353: Fix xclip blocking on X11 (@chemtov)
• #363: Configurable session selection columns (@Cy6erBr4in)
• #370: Fix permission UI on out-of-order status updates (@xar7)
• #374: Indent markdown headers in transcript (@systemfreund)
• #376: Fix file skip check (@zackattackz)
• #378: Configurable dot-subdir location (@zackattackz)
• #382: Permission-request and turn-complete subscription events (@emil-e)
• #383: Viewport context on first open (@liaowang11)
• #385: Fix leading space in terminal prompt (@bcc32)
• #388: Apply dir-local variables in shell buffer (@fritzgrabo)

Bug fixes

• #168: replace-buffer-contents timeout to prevent freeze on large diffs
• #170: Suppress effects of find-file-noselect during agent writes
• #175: ACP configuration JSON-RPC inserted into shell
• #180: Terminal-friendly keybindings
• #189: Changing the model with Claude causes hang
• #191: user_message_chunk session updates no longer dump raw JSON
• #220: Python comments no longer interpreted as Markdown headers
• #265: session/request_permission with argv array commands
• #297: Unexpected tool-call command type error
• #300: agent-shell-send-region no longer fails silently without a region
• #303: Context insertion for new deferred sessions
• #319: Fix "Wrong type argument: font, unspecified" in terminal Emacs (fix by @eddof13)
• #335: Plan not displaying from session/request_permission (fix by @Azkae)
• #345: Out of turn notifications inserted into shell
• #353: xclip handler blocking on X11 when clipboard has no image (fix by @chemtov)
• #361: loadSession regression
• #370: Permission UI not reacting on status failed/completed (fix by @xar7)
• #376: File skip check using full path instead of filename only (fix by @zackattackz)
• #385: Leading space in agent-shell-select-config prompt in terminal frames (fix by @bcc32)

Lots of polish

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

Make the work sustainable

If agent-shell is useful to you, please consider sponsoring the project. These days, I've been working on agent-shell daily.

LLM tokens aren't free, and neither is the time dedicated to building this stuff. While I now have more time to work on agent-shell as an indie dev, I also have bills to pay ;)

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

I am currently reading Clojure for the brave and true by Daniel Higginbotham and in Chapter 2 about how to use Emacs for Clojure, there are instructions on how to set up Emacs with Cider, a Clojure REPL. I tried installing the package with a use-package configuration with :ensure t and I got the package. However, when I tried using it as the book instructed, I just got an error. I then realised the need for OpenJDK and Clojure and installed those with my home-config.scm file in Guix. I tried again and I still got the same error. I then tried installing emacs-cider from Guix as well with the hope that maybe there was some kind of incompatibility between OpenJDK, Clojure and Cider that was ironed out in the guix package. It still did not work.

I tried looking up the error and found a blog post that suggested installing OpenJDK non-Guixily by downloading a binary and adding it to the $PATH which solved the problem for that user. I did not really want this, since I really like the idea of installing my whole system with a scheme file or two in a reproducible way. (I'm not there yet, but I hope to get there over time. I just started using Guix as my main distro a few weeks ago. For now, after installing Guix System or Guix on another distro, I do some manual work and then run a Shell script to set up a few folders and run the command that applies my home-config.)

Tonight, a day later, I DuckDuckWent again and found another blog post about Clojure that told me that since there are three outputs for the openjdk package, to get everything I would need for Clojure, I should install openjdk:jdk, not simply openjdk which would give me openjdk:out. In addition, I also added openjdk:doc since I am a fan of having as much documentation as possible available on my local machine. I saw a video where that documentation was read from inside Cider a couple of days ago, so I thought it might come in handy. Come to think of it, maybe that was accessed over the internet, not from the local machine. Anyway, it doesn't hurt to have some documentation.

And now, everything just works. Turns out the problem was just user error. Whenever there are multiple outputs of a package in Guix, it is important to know what you get with each output and choose accordingly. As someone who just recently switched my main machine to Guix, this is very useful information that I had not seen before. I thought I would write this up in a blog post so people out there trying to fix the same problem have a chance of finding a solution faster than I did, and for my own future reference.

I got inspired to look into this topic after receiving the following obscure bug report for neocaml:

I had your package installed. First impressions were good, but then I had to uninstall it. The code formatting on save stopped working for some reason, and the quickest solution was to revert to the previous setup.

I found this somewhat entertaining – neocaml is a major mode, it has nothing to do with code formatting. But I still started to wonder what kind of setup that user might have. So here we are!

Code formatting is one of those things that shouldn’t require much thought – you pick a formatter, you run it, and your code looks consistent. In practice, Emacs gives you a surprising number of ways to get there, from built-in indentation commands to external formatters to LSP-powered solutions. This article covers the landscape and helps you pick the right approach.

One thing to note upfront: most formatting solutions hook into saving the buffer, but there are two distinct patterns. The more common one is format-then-save (via before-save-hook) – the buffer is formatted before it’s written to disk, so the file is always in a formatted state. The alternative is save-then-format (via after-save-hook) – the file is saved first, then formatted and saved again. The second approach can be done asynchronously (the editor doesn’t block), but it means the file is briefly unformatted on disk. Keep this distinction in mind as we go through the options.

Built-in: Indentation, Not Formatting

Let’s get the terminology straight. Emacs has excellent built-in indentation support, but indentation is not the same as formatting. indent-region (C-M-\) adjusts leading whitespace according to the major mode’s rules. It won’t reformat long lines, reorganize imports, add or remove blank lines, or apply any of the opinionated style choices that modern formatters handle.

That said, for many languages (especially Lisps), indent-region on the whole buffer is all the formatting you’ll ever need:

;; A simple indent-buffer command (Emacs doesn't ship one)
(defun indent-buffer ()
  "Indent the entire buffer."
  (interactive)
  (indent-region (point-min) (point-max)))

Tip: whitespace-cleanup is a nice complement – it handles trailing whitespace, mixed tabs/spaces, and empty lines at the beginning and end of the buffer. Adding it to before-save-hook keeps things tidy:

(add-hook 'before-save-hook #'whitespace-cleanup)

Shelling Out: The DIY Approach

The simplest way to run an external formatter is shell-command-on-region (M-|). With a prefix argument (C-u M-|), it replaces the region with the command’s output:

C-u M-| prettier --stdin-filepath foo.js RET

(The --stdin-filepath flag doesn’t read from a file – it just tells Prettier which parser to use based on the filename extension.)

You can wrap this in a command for repeated use:

(defun format-with-prettier ()
  "Format the current buffer with Prettier."
  (interactive)
  (let ((point (point)))
    (shell-command-on-region
     (point-min) (point-max)
     "prettier --stdin-filepath foo.js"
     (current-buffer) t)
    (goto-char point)))

This works, but it’s fragile – no error handling, no automatic file type detection, and cursor position is only approximately preserved. For anything beyond a quick one-off, you’ll want a proper package.

reformatter.el: Define Your Own (Re)Formatters

reformatter.el is a small library that generates formatter commands from a simple declaration. You define the formatter once, and it creates everything you need:

(reformatter-define black-format
  :program "black"
  :args '("-q" "-")
  :lighter " Black")

This single form generates three things:

• black-format-buffer – format the entire buffer
• black-format-region – format the selected region
• black-format-on-save-mode – a minor mode that formats on save

Enabling format-on-save is then just:

(add-hook 'python-mode-hook #'black-format-on-save-mode)

reformatter.el handles temp files, error reporting, and stdin/stdout piping. It also supports formatters that work on files instead of stdin (via :stdin nil and :input-file), and you can use buffer-local variables in :program and :args for per-project configuration via .dir-locals.el.

I love the approach taken by this package! It’s explicit, you see exactly what’s being called, and the generated on-save mode plays nicely with the rest of your config.

format-all: Zero Configuration

format-all takes a different approach – it auto-detects the right formatter for 70+ languages based on the major mode. You don’t define anything; it just works:

(add-hook 'prog-mode-hook #'format-all-mode)
(add-hook 'prog-mode-hook #'format-all-ensure-formatter)

The main command is format-all-region-or-buffer. The format-all-mode minor mode handles format-on-save. If you need to override the auto-detected formatter, set format-all-formatters (works well in .dir-locals.el):

;; In .dir-locals.el -- use black instead of autopep8 for Python
((python-mode . ((format-all-formatters . (("Python" black))))))

;; Or in your init file
(setq-default format-all-formatters '(("Python" black)))

The trade-off is less control – you’re trusting the package’s formatter database, and debugging issues is harder when you don’t see the underlying command.

apheleia: Async and Cursor-Aware

apheleia is the most sophisticated option. It solves two problems the other packages don’t:

1. Asynchronous formatting – it runs the formatter after save, so the editor never blocks. If you modify the buffer before formatting completes, the result is discarded.
2. Cursor preservation – instead of replacing the entire buffer, it applies changes as RCS patches (a classic diff format from one of the earliest version control systems), so your cursor position and scroll state are maintained.

;; Enable globally
(apheleia-global-mode +1)

apheleia auto-detects formatters like format-all, but you can configure things explicitly:

;; Chain multiple formatters (e.g., sort imports, then format)
(setf (alist-get 'python-mode apheleia-mode-alist)
      '(isort black))

Formatter chaining is a killer feature – isort then black, eslint then prettier, etc. No other package handles this as cleanly.

Caveat: Because apheleia formats after save, the file on disk is briefly in an unformatted state. This is usually fine, but it can confuse tools that watch files for changes. It also doesn’t support TRAMP/remote files.

LSP: eglot and lsp-mode

If you’re already using a language server, formatting is built in. The language server handles the formatting logic, and Emacs just sends the request.

eglot (built-in since Emacs 29)

The main commands are eglot-format (formats the active region, or the entire buffer if no region is active) and eglot-format-buffer (always formats the entire buffer).

Format-on-save requires a hook – eglot doesn’t provide a toggle for it:

(add-hook 'eglot-managed-mode-hook
          (lambda ()
            (add-hook 'before-save-hook #'eglot-format-buffer nil t)))

The nil t makes the hook buffer-local, so it only fires in eglot-managed buffers.

lsp-mode

The equivalents here are lsp-format-buffer and lsp-format-region.

lsp-mode has a built-in option for format-on-save:

(setq lsp-format-buffer-on-save t)

It also supports on-type formatting (formatting as you type closing braces, semicolons, etc.) via lsp-enable-on-type-formatting, which is enabled by default.

LSP Caveats

• Formatting capabilities depend entirely on the language server. Some servers (like gopls or rust-analyzer) have excellent formatters; others may not support formatting at all.
• The formatter’s configuration lives outside Emacs – in .clang-format, pyproject.toml, .prettierrc, etc. This is actually a feature if you’re working on a team, since the config is shared.
• LSP formatting can be slow for large files since it’s a round-trip to the server process.

Which Approach Should You Use?

There’s no single right answer, but here’s a rough guide:

• Lisps and simple indentation needs: Built-in indent-region is probably all you need.
• Specific formatter, full control: reformatter.el – explicit, simple, and predictable.
• Many languages, minimal config: format-all or apheleia. Pick apheleia if you want async formatting and cursor stability.
• Already using LSP: Just use eglot-format / lsp-format-buffer. One less package to maintain.
• Mixed setup: Nothing stops you from using LSP formatting for some languages and reformatter.el for others. Just be careful not to have two things fighting over format-on-save for the same mode.

Tip: Whichever approach you choose, consider enabling format-on-save per project via .dir-locals.el rather than globally. Not every project uses the same formatter (or any formatter at all), and formatting someone else’s unformatted codebase on save is a recipe for noisy diffs.

;; .dir-locals.el
((python-mode . ((eval . (black-format-on-save-mode)))))

Epilogue

So many options, right? That’s so Emacs!

I’ll admit that I don’t actually use any of the packages mentioned in this article – I learned about all of them while doing a bit of research for alternatives to the DIY and LSP approaches. That said, I have a very high opinion of everything done by Steve Purcell (author of reformatter.el, many other Emacs packages, a popular Emacs Prelude-like config, and co-maintainer of MELPA) and Radon Rosborough (author of apheleia, straight.el, and the Radian Emacs config), so I have no issue endorsing packages created by them.

I’m in camp LSP most of the time these days, and I’d guess most people are too. But if I weren’t, I’d probably take apheleia for a spin. Either way, it’s never bad to have options, right?

There are languages where LSP isn’t as prevalent – all sorts of Lisp dialects, for instance – where something like apheleia or reformatter.el might come in handy. But then again, in Lisps indent-region works so well that you rarely need anything else. I’m a huge fan of indent-region myself – for any good Emacs mode, it’s all the formatting you need.

In the previous article in the Emacs ways series we did a little jive on copying files from one source location to a destination location. As you can imagine, this keeps a copy in the source location and creates a copy in the destination location—exactly what you would expect.

Now, what if you don’t want a copy in the source location, but want to move that file completely to a different location? Or, what if you wanted to keep the source file in place but merely change the name?

This is where the UNIXy way of doing things can be a little confusing, and I think the Emacs way is superior, but I will let you be the judge of that.

If you are a writer interested in introducing open source tools into your workflow, you will love my DRM-free eBooks:

• Emacs For Writers
• Git For Writers

Now let’s get into some Emacs fun.

mv old_name.txt new_name.txt
mv file.txt /path/to/destination/
mv -v *.org ~/documents/

$ mv -v old_name.txt new_name.txt
renamed 'old_name.txt' -> 'new_name.txt'

$ mv -v report.txt ~/documents/
renamed 'report.txt' -> '/home/user/documents/report.txt'

$ mv -v *.org ~/documents/
renamed 'notes.org' -> '/home/user/documents/notes.org'
renamed 'todo.org' -> '/home/user/documents/todo.org'

  /home/user/projects:
  -rw-r--r--  1 user user 1234 Jan  8 14:22 draft.txt

Rename draft.txt to: final.txt

 Rename from (regexp): \.txt$
 Rename to: .org

   /home/user/notes:
 * -rw-r--r--  1 user user 1234 Jan  8 14:22 ideas.txt
 * -rw-r--r--  1 user user 5678 Jan  7 09:15 plans.txt

Rename ideas.txt to ideas.org? (y or n) y
Rename plans.txt to plans.org? (y or n) y

The post The Emacs Way: Moving and Renaming Files appeared first on Chris Maiorana.

Writing quizzes in Canvas is, to put it mildly, a pain in the neck, especially for keyboard-centric users. Every tiny step in the process requires a mouse click, something that quickly becomes irritating. Fortunately, the New York Institute of Technology provides the Canvas Exam Converter which takes a formatted text file and converts to an XML file that Canvas can import. This means that, with a little help from Emacs, writing quizzes that can be quickly imported into Canvas is quick and easy. (See my 2024 post, Converting Org Files to Canvas Quizzes for details.)

Coming up with good questions is still a challenge, though. It turns out that Claude is very effective at writing good multiple choice questions from a document. The questions are formatted like this:

**Question 1:** According to Aristotle, which of the following best describes distributive justice?

- A) Restoring equality after a wrong has been committed
- B) Equality of ratios based on factors like merit, need, or virtue
- C) Following the laws of society without exception
- D) Maximizing overall welfare for the greatest number of people

---

**Question 2:** Which of the following is a criticism of the Utilitarian approach to punishment?

- A) It fails to consider the consequences of punishment
- B) It relies too heavily on retribution
- C) It can justify punishing the innocent if doing so maximizes good outcomes
- D) It requires the punishment to exactly fit the crime

To run my conversion function for sending to NYIT, I first need it in this form:

1. According to Aristotle, which of the following best describes distributive justice?
     a) Restoring equality after a wrong has been committed
     b) Equality of ratios based on factors like merit, need, or virtue
     c) Following the laws of society without exception
     d) Maximizing overall welfare for the greatest number of people
2. Which of the following is a criticism of the Utilitarian approach to punishment?
     a) It fails to consider the consequences of punishment
     b) It relies too heavily on retribution
     c) It can justify punishing the innocent if doing so maximizes good outcomes
     d) It requires the punishment to exactly fit the crime

For weeks, I’ve been converting them a series of regex search and replace operations, but why do that every time? One of the main reasons I use Emacs is to avoid repetitive, tedious tasks. Here’s the function:

(defun convert-quiz-claude-to-org ()
  "Convert markdown-style quiz questions from Claude to Org mode format. Operates on the current buffer or active region."
  (interactive)
  (let ((start (if (use-region-p) (region-beginning) (point-min)))
          (end   (if (use-region-p) (region-end)       (point-max)))
          (question-num 0))
    (save-excursion
      ;; Remove '---' separator lines
      (goto-char start)
      (while (re-search-forward "^---\n?" end t)
          (replace-match ""))

      ;; Convert **Question N:** to "N."
      (goto-char start)
      (while (re-search-forward "^\\*\\*Question [0-9]+:\\*\\* " end t)
          (setq question-num (1+ question-num))
          (replace-match (format "%d. " question-num)))

      ;; Convert "- A)" "- B)" etc. to "     a)"  "     b)" etc.
      (goto-char start)
      (while (re-search-forward "^- \\([A-D]\\))" end t)
          (replace-match (format "     %s)" (downcase (match-string 1)))))

      ;; Remove blank lines
      (goto-char start)
      (while (re-search-forward "^[[:blank:]]*\n" end t)
          (replace-match "")))))