HTML defines a hierarchy of headings going from <h1> to <h6>, which comes in especially handy when people are navigating with a screenreader or converting web pages to Org Mode. I think search engines might use them to get a sense of the page's structure, too. On my blog, the hierarchy usually goes like this:

• <h1>: site title,
• <h2>: blog post titles, since I put multiple blog posts on the main page and category pages (ex: blogging)
• <h3>: blog post's subheadings, if any
• <h4>: I rarely need subsubheadings in my main blog posts, but they're there just in case

While fiddling with my blog's CSS so that I could try this fluid type scale, I realized that the subheadings in my exported blog entries started at <h2> instead of <h3>. This meant that the outline was this:

• Site title
  • Blog post 1
  • Subheading 1
  • Subheading 2
  • Blog post 2
  • Subheading 1
  • Subheading 2
  • Blog post 3

I wanted the outline to be this:

• Site title
  • Blog post 1
    • Subheading 1
    • Subheading 2
  • Blog post 2
    • Subheading 1
    • Subheading 2
  • Blog post 3

This was because I hadn't changed org-html-toplevel-hlevel during my 11ty export process. To solve this for new posts, I added a new option org-11ty-toplevel-hlevel that defaults to 3 in ox-11ty.el, re-exported one of my long blog posts to test it, and confirmed that my headings now started at <h3>.

I still had all my old HTML files with the wrong levels of headings. I wrote some Emacs Lisp to shift the headings downwards (h5 to h6, h4 to h5, h3 to h4, h2 to h3) in a file if it had an <h2> in it. Regular expressions are usually not a good idea when it comes to HTML because there might be exceptions, but I figured it was a pretty small and low-risk change, so I decided not to use the full XML/DOM parsing functions. I saved all the blog posts under version control just in case I messed things up. Here's my function:

(defun my-html-shift-headings (filename)
  "Shift heading tags in FILENAME."
  (interactive "FFile: ")
  (let ((case-fold-search t)) ; make the search case-insensitive
    (with-temp-buffer
      (insert-file-contents filename)
      (goto-char (point-min))
      ;; Only modify the files where we have an h2
      (when (or (search-forward "<h2" nil t)
                (search-forward "</h2>" nil t))
        (goto-char (point-min))
        ;; Handle both opening and closing tags
        (while (re-search-forward "<\\(/\\)?h\\([2-5]\\)\\>" nil t)
          (let* ((closing-tag (match-string 1))
                 (heading-level (string-to-number (match-string 2)))
                 (new-level (1+ heading-level)))
            (replace-match (concat "<" closing-tag "h" (number-to-string new-level)))))
        (write-file filename)
        filename))))

Running it on all the source HTML files in specific subdirectories was easy with directory-files-recursively.

(dolist (dir '("~/proj/static-blog/blog"
               "~/proj/static-blog/content"))
  (mapc 'my-html-shift-headings
        (directory-files-recursively
         dir
         "\\.html\\'")))

Then I could just rebuild my blog and get all the right heading levels. Spot-checks with Inspect Element show that the headings now have the right tags, and org-web-tools-read-url-as-org now picks up the right hierarchy for the page.

Correcting the input files was easier and more efficient than modifying my 11ty template engine to shift the heading levels whenever I build my site (probably by defining a preprocessor). I could've written a NodeJS script to do that kind of file manipulation, but writing it in Emacs Lisp matched how I might think of doing it interactively. Using Emacs Lisp was also easy to test on one or two files, check the list of files matched by directory-files-recursively, and then run it on everything.

Going forward, the new org-11ty-toplevel-hlevel variable should properly modify the behaviour of Org's HTML export to get the headings at the right level. We'll see!

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

Over at The Art Of Not Asking Why, JTR suspects that I may be an apostate, or at least that I’m inconsistent. He notes, correctly, that I’m all in on Emacs in general and Org mode in particular, and yet I’ve lately expressed enthusiasm for the non-Emacs app Journelly. He wonders why. It’s a good question and an honest one that deserves an answer. I’m sure others are wondering too.

I explained my initial attraction in my first post on Journelly. The TL;DR is that I use the Apple Notes app to keep a running memo book of each day’s events but that I was looking for something a bit better. Journelly seemed like it might be an answer so I resolved to keep an eye on it. Shortly afterwards, Ramírez started a formal beta program and after some initial dithering I signed up and started playing with Journelly.

I will shortly write about my experiences with it but in this post I want to address why a dedicated Emacs/Org mode user, who writes virtually everything in Org mode, might want to use Journelly. The thing is even I am not always on my computer. Sometimes I’m out and about, and sometimes I’m just doing other things. That means that I’ll be using my iPhone. Apple’s policy prohibiting apps with interpreters means that Emacs will never be on iOS but even if it were, I can’t imagine that the experience would be very pleasant. What I need is a way of easily adding entries to my Memo Book and having those entries sync across all my devices, including my Mac.

That’s where Journelly shines. Although the beautiful iPhone display doesn’t suggest it, the records are actually recorded in standard Org mode. Since it’s also possible to store the Journelly files in the iCloud, you can get access to them with a Mac, iPad, or, I suppose, another iPhone.

Jack Baty has a nice post that describes how he’s sharing data between his iPhone and his Mac. He even has an Org template to capture entries on his Mac. It’s actually trivial and at this point I’m sharing Journelly data between my iPhone, Mac, and iPad.

Finally, Álvaro Ramírez also saw JTR’s post and wrote his own answer. The TL;DR there is, “Why not both?” Like me, he was looking for an easy way to take notes when he wasn’t at his computer but wanted to be able to access and edit them in Org mode as usual when he was. That’s why he arranged for the records to be kept in Org mode format.

Sure, as JTR says, there are apps like Beorg but they, while great, aren’t targeted at my—and presumably Ramírez’s—needs. It’s not a matter of choosing between Org and some proprietary app; it’s about choosing a useful Org front end for your iPhone.

As a coda to this post, JTR notes in a subsequent post that he didn’t realize that Journelly kept its records in Org format and now that he does, he better understands my attraction to it.

Another quick note about Journelly -

Álvaro Ramírez was kind enough to grant me access to test the app after I found out it’s based on org-mode.

I just started playing around with it but so far I’m impressed, particularly with its ability to “talk to” Emacs back on my Mac. I can easily edit notes that I created on the phone, and these edits, including links, strikethroughs, and lists, show up on the app in turn.

There’s more to explore and the app is still in beta, so I will give it a couple of days before I write something more thorough.

When I wrote about Journelly the other day, I didn’t expect the guy who makes the app to find me and my post, and answer my post on his own blog. It surprises me every time I get an email or a response because I don’t really think anyone really reads this blog.

It makes sense that some Emacs folks on Fosstodon would find me, sure, we’re all crazy for the same thing after all, but then I also get email from people who take the time to write in length and open up more, and I just feel this semi-guilt of, “hey, why are you reading my stuff, I’m just talking nonsense.”

My most popular posts (I use TinyLytics to track traffic, it’s by an independent developer, and it just tracks the essentials, like general geographical location and browser used to read what pages) are Emacs and org-mode related, without a doubt, but there are other posts here as well. As time passes, I open up about more things in my life, or I care less about what people think, or probably a mix of both - and I’m also getting comments about those here and there. That’s especially exciting to me.

First, there’s some sense of vindication in that (if you grew up being somewhat on any social spectrum, you’ve probably experience enough of “you are wrong and you need to do X because X is what the rest of the world is doing” kind of thing). Second, these communications are always more personal and human. Emacs communications is great too, but it’s more of the thrill of learning a new thing.

Back to Journelly. I owe both Irreal and Álvaro an apology. Not that what I said was negative criticism in any way (and if it was, I didn’t mean it that way) - it’s just that I didn’t do enough research to learn about the app. I just read the review linked from Irreal, which didn’t really highlight the fact that the app is based on org-mode. That’s a big DUH, folks! Álvaro also created Plain Org, which I’ve used, among other useful Emacs surprises!

I’ve added experimental support for Claude AI, aligning its implementation with my support for ChatGPT, to pave the way for external AI templating which should make it easier to integrate new models in the future. Like the ChatGPT implementation, it doesn’t stream tokens in real time but instead outputs the final result all at once. However, after testing it further, I’m actually starting to prefer it. The response speed is so fast that not seeing a real-time “Typing” indicator isn’t a big deal. I think that streaming feels more relevant for local LLMs running through ollama, where token generation is slower, making real-time output more useful.

Secondly, the Texinfo manual for this package now magically installs itself when pulling from MELPA. I fluked this!, I just thought it was sensible to create a docs directory and then plonked an info file there. After looking into it, I found that MELPA performs some extra processing when handling Emacs documentation. It automatically scans common documentation directories like docs and grabs the .info file, pretty neat! This means you can now browse ollama-buddy’s functionality directly through info.

Next up, I realized I wasn’t efficiently handling ollama model operations like delete, pull, and copy. I was currently process-calling ollama and passing through arguments as if I was on the command line. This was functional, but wasn’t ideal and wasn’t stimulating the ollama API for these operations correctly, or even at all. After reassessing my design, I came to the realization that I was in fact using four different methods to communicate with ollama:

1. curl
2. Direct process calls
3. url.el
4. make-network-process

At first, I leaned on curl since it was straightforward and matched the official ollama examples. My approach with a project such as this is generally to get things working quickly and then refine/iterate later. However, once I had a solid design (and design principles!), I wanted to eliminate external dependencies like curl. This lead me to explore url.el, but initially I couldn’t seem to get my head round it / get it working - and I decided to go for the nuclear option of make-network-process for network-level flexibility. Later, I revisited url.el for Claude and ChatGPT support, rewriting the implementation to use url-retrieve, but decided generally to keep make-network-process for ollama interactions as it was still Emacs built-in and actually I’m more familiar with the lower level network concepts as having wrestled with them over many years at work.

Anyway, back to the stimulating of the ollama API for model operations.

I considered leveraging my existing url.el based ollama-buddy--make-request function, but quickly realized it used url-request-data, which blocks execution. This wasn’t an issue for quick requests like model info or tags (although could be), but for long-running tasks like model pulls and general model operations it risked freezing Emacs!

Switching to url-retrieve solved this, as it runs asynchronously, however, url-retrieve only triggers its callback at the end of the request, making real-time progress tracking difficult. To address this, I implemented run-with-timer, ensuring persistent status updates in the header-line which now allows for multiple operations, including pull, copy, delete, even simultaneously.

Now that I’m using ollama-buddy as my primary Emacs AI assistant, I’m refining my AI workflow. Since my design is centered around the chat buffer, all interactions and outputs end up there. But what about quick tasks like proofreading text or refactoring code? Ideally, I want a workflow that aligns with ollama-buddy’s principles, meaning no direct in-buffer edits (though future me might change their mind!).

For example, if I want to tighten a rambling paragraph (is this one? :), I currently send it via the custom menu to the chat buffer with a proofreading tag. However, retrieving the output requires jumping to the chat buffer, copying it, switching back, deleting the original, and then pasting the revision - too many steps.

To streamline this, I’ve now implemented a feature that writes the latest response to a customizable register, this way, I can simply delete the original text and insert the improved version without extra navigation.

Note: I have remapped the insert-register default keybinding of C-x r i to M-a, as by default I am writing to register ?a and M-a a seems more comfortable.

<2025-04-01 Tue> 0.9.17

• Added link to ollama-buddy info manual from the chat buffer and transient menu as MELPA has now picked it up and installed it!

<2025-03-28 Fri> 0.9.16

• Added ollama-buddy-fix-encoding-issues to handle text encoding problems.
• Refactored and streamline fabric pattern description handling.
• Removed unused fabric pattern categories to enhance maintainability.

<2025-03-28 Fri> 0.9.15

• Implement asynchronous operations for model management
  • Introduce non-blocking API requests for fetching, copying, and deleting models
• Add caching mechanisms to improve efficiency
  • Cache model data to reduce redundant API calls
  • Manage cache expiration with timestamps and time-to-live settings
• Update status line to reflect ongoing background operations
• Ensure smooth user interaction by minimizing wait times and enhancing performance

<2025-03-26 Wed> 0.9.13

• Added automatic writing of last response to a register
• Added M-r to search through prompt history

I was just thinking about a general workflow aspect and that is getting responses out of the ollama-buddy chat buffer. Of course if you are already there then it will be easier, but even then the latest prompt, which is probably the one you are interested in will still have to be copied to the kill ring.

This issue is even more pronounced when you are sending text from other buffers to the chat.

So, the solution I have put in place is to always write the last response to a register of your choice. I always think registers are an underused part of Emacs, I already have repurposed them for the multishot, so why not always make the last response available.

For example, you want to proofread a sentence, you can mark the text, send to the chat using the custom menu to proofread then the response will be available in maybe register “a”. The chat buffer will be brought up if not already visible so you can validate the output, then pop back to your buffer, delete the paragraph and insert the register “a”?, maybe. I am going to put this in as I suspect no-one uses registers anyway and if they do, they can push the response writing register away using ollama-buddy-default-register, I don’t think this will do any harm, and actually it is something I may starting using more often.

As a side note, I also need to think about popping into the chat buffer with a buffer text push to the chat, should I do it?, not sure yet, still getting to grips with the whole workflow aspect, so will need a little more time to see what works.

Also as a side note to this ramble, the general register prefix is annoyingly long C-x r i <register> so I have rebound in my config to M-a, as I never want to go back a sentence and also if I just write to the default “a” register then it feels ergonomically fast.

<2025-03-25 Tue> 0.9.12

• Added experimental Claude AI support!
• removed curl and replaced with url.el for online AI integration

A very similar implementation as for ChatGPT.

To activate, set the following:

(require 'ollama-buddy-claude nil t)
(ollama-buddy-claude-api-key "<extremely long key>")

I just came across a link to this recently updated book on the plain text computing environment. It was, apparently, first written to describe Emacs 19.29 around 1997. That was a long time ago and Emacs has evolved considerably since then. Happily, the book has recently been updated to Emacs 29.4. It’s over 600 pages so there’s a lot of content.

You can see the book here, There’s an interactive menu on the left that will give you an idea of what’s available. Besides HTML, it’s available in PDF and various EPUB formats. At more than 600 pages there’s obviously lot of content but the author, Keith Waclena, says that while you could read it straight through, he doubts many people will. Rather, it’s designed to enable you to skip to any topic you’re interested in.

Obviously, I haven’t been through the book in detail—having just discovered it—but it seems like a useful resource, especially for users new to Emacs. Take a look, especially if your a n00b.

To read my newspapers I load my RSS feed via the elfeed package.
…
Also, I identify any RSS feed entry that does not provide the full text. And those live in provisional status. My reflexes are to ask “there’s lots of full-text feeds, why bother with this truncation?”

Jeremy Friesen, A Walk Through My Digital Neighborhood

Jeremy is totally right! – it came to my mind immediately.

I’m using the Hugo static site generator to build this blog. Hugo uses content summaries to display a list of blog entries on the main page. As a result, the Elfeed entry shows a summary of the post instead of the full text.

Many of us – including me – are using Elfeed as an RSS reader, and I have realized that the truncated Elfeed entry may cause inconvenience to the Elfeed users.

Applying some tricks I was able to disable the automatic displaying of summaries on the main page. I hope it has become more comfortable for those who use Elfeed for reading RSS feeds.

Happy elfeeding!

– The Emacs Cat.

P.S. Thanks to Jeremy Friesen for the heads up.

I saw the Irreal post about Journelly, but mostly ignored it because I wasn’t looking for a new iOS journaling app. He did mention that Journelly is by Álvaro Ramírez, author of Plain Org, lmno.lol, and others, so that made things more interesting.

What intrigued me most, though, was learning that Journelly is backed by plain-text Org Mode files. Bonus! Now it had my attention.

Álvaro was kind enough to let me into the TestFlight, and I’m putting it through its paces this morning.

Here’s what mine looks like so far…

Simple and easy to use, so that’s good. As Álvaro desribed Journelly, it’s like a personal, private Twitter/Instagram/Mastodon account.

Speaking of simple, the entire journal is kept as a single journelly.org file. I chose to sync mine via iCloud, which meant that I could view and edit it locally on my Mac. The problem with iCloud Drive’s default storage locations is that they’re in a stupid place, e.g. /Users/jbaty/Library/Mobile Documents/iCloud~com~xenodium~Journelly/Documents/Journelly.org. Don’t make me create symlinks, iCloud! 😄

Digging into the settings, I noticed that in addition to the default iCloud Drive folder, I could configure Journelly to use any folder in iCloud, including my ever-popular ~/Documents/Notes folder. Much better.

Since I use Emacs for most everything, including my journals, I’ve never done much journaling on my Phone. Journelly could change this equation.

It would be cool if I could use Journelly from my Mac as well. To that end, I created an Org Mode capture template to make it easy to add entries while in Emacs on my Mac.

("j" "Journelly Entry" entry
           (file "~/Documents/Notes/Journelly/Journelly.org")
           "* %U @ -\n%?" :prepend t)

I can now hit C-c c j and I’m in a capture buffer for the Journelly file. The Journelly app can include weather and location to new entries. Currently, my capture template isn’t smart enough to do that, but it could be, with just a bit of work.

It’s only been a couple of hours with Journelly, so this isn’t meant to be a review, but first impressions are that it’s handy, simple, and could work well as an adjunct to my existing Org mode based note-taking setup.

For a recent review of Journelly, see Monday App Finder: Journelly, a Twitter-Like Journal for iOS - The Mac Observer.

Here’s yet another post commenting on something that Bozhidar Batsov wrote on Emacs Redux. I like to write about his posts because they typically look at some Emacs functionality that we all thought we knew about and tells us things about that functionality that we didn’t know.

His latest post is about flyspell. I’ve been using flyspell for so long that I have no memory of when I started or how I discovered it. On the other hand, my sole use of it is to invoke flyspell-auto-correct-previous-word with its default binding of Ctrl+;. I was vaguely aware that you could do manual checks or even check a whole buffer but I never used them.

Batsov’s post discusses some of those other commands. You can, for example, use Ctrl+, to move to the next misspelling. Then you can use Ctrl+. or Ctrl+; to correct it.

I like Ctrl+; because the point doesn’t have to be on the misspelling; it corrects the previous error wherever it is. Batsov, on the other hand, likes Ctrl+c $ because it gives you a menu of possible corrections as well as options to accept it in the current buffer, accept it in the current session, or add it to your dictionary. The key binding is—for me—significantly more awkward so I’m going to stick with Ctrl+; unless I want to add the word to my dictionary.

But Batsov is a serious Emacs user and his recommendations shouldn’t be ignored. Read his post and see what you think. As usual, Emacs has got you covered whatever your preferences.

Update [2025-04-01 Tue 21:29]: Fix link.

Irreal likes Ramírez’s Journelly. To each their own, sure, but after I read the review he mentioned, I’ve been scratching my head a bit. I don’t get it.

Irreal is a dedicated Emacs user, and I estimate he uses more Emacs in his day-to-day functions than I do - so why does he feel the need to use something that is not Emacs for quick notes?

One of my theories is iPhone usage. That’s probably a big one. Using org-mode on an iPhone is not easy. There’s Beorg, but it’s geared more toward task lists and calendars than taking notes (even though you can do that, especially if you have templates). Even better, you could include a timestamp every time you record a new note, which is one of Irreal’s needs of his requirements. I’m not sure if he wants to include voice recordings or dictate notes on his iPhone, but both of these things are pretty easy to do - exporting an audio note and attaching it to a header in org-mode is pretty straightforward and can probably be automated.

My issue with any such apps, especially if they’re meant to capture “everything” (like pictures, short videos, oral notes, etc.), is that pretty soon they start competing with org-mode. What follows is confusion about what I put where which is usually followed by a short burnout of using either one. Then I have a period when I don’t save anything, and I regret it later.

org-mode is not perfect, but as long as I use it, I have one place where I know I can find whatever I need. At work, I usually keep detailed notes of what I did under each header with timestamps, even if they are just a few lines long. It’s more than just recording information: the act of writing clears up my head and helps me figure out what goes next, and the “emotional memory” (for lack of a better term) reflected in the mood of my notes helps me remember things later that I didn’t think of actually writing down. I can find old records this way, even if they happened years ago.

As I already said, to each their own. We all get to choose what tools we want to use. This is not about preaching; it’s just that his use case makes me put my Emacs thinking hat on and think about what I would do. These scenarios are interesting to solve.

I’d love to write him an email or comment, but I can’t find an email address, and the blog’s commenting system uses Disqus, which doesn’t let me log in with any accounts I want to use. Oh well. Maybe he will find this post.

I’ve been a long time user of flyspell-mode and flyspell-prog-mode, but admittedly I keep forgetting some of it’s keybindings. And there aren’t that many of them to begin with!

This article is my n-th attempt to help me memorize anything besides C-c $. So, here we go:

• M-t (flyspell-auto-correct-word) - press this while in word with typo in it to trigger auto-correct. You can press it repeatedly to cycle through the list of candidates.
• C-, (flyspell-goto-next-error) - go to the next typo in the current buffer
• C-. (flyspell-auto-correct-word) - same as M-t
• C-; (flyspell-auto-correct-previous-word) - automatically correct the last misspelled word. (you can cycle here as well)

Last, but not least, there’s the only command I never forget - C-c $ (flyspell-correct-word-before-point). Why is this my go-to command? Well, its name is a bit misleading, as it can do two things:

• auto-correct the word at (or before) point
• add the same word to your personal dictionary, so Flyspell and ispell will stop flagging it

Good stuff!

There are more commands, but those are the ones you really need to know.¹

If you ever forget any of them, just do a quick C-h m RET flyspell-mode.

Do you have some tips to share about using flyspell-mode (and maybe ispell as well)?

That’s all I have for you today! Keep fixing those typos!

P.S. If you’re completely new to flyspell-mode, you may want to check this article on the subject as well.

• Emacs 30:
  • TAONAW - Emacs and Org Mode: Emacs 30.1 so far
• Help wanted:
  • Show your post-command-hook contents to help Emacs core
• Upcoming events (iCal file, Org):
  • Emacs Paris: S: Emacs workshop in Paris (online) https://emacs-doctor.com/ Tue Apr 1 0830 America/Vancouver - 1030 America/Chicago - 1130 America/Toronto - 1530 Etc/GMT - 1730 Europe/Berlin - 2100 Asia/Kolkata - 2330 Asia/Singapore
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/306712497/ Wed Apr 2 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Thu Apr 3 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Apr 4 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Apr 11 1800 Europe/Paris
• Beginner:
  • Waclena, K. (2024) Use GNU Emacs (HTML, PDF, or ePub) (@barocio@techhub.social)
  • Installing and testing out Emacs for the first time, as a Neovim user With Joshua Blais (1 hour video)
• Emacs configuration:
  • Emacs Redux: Speed up Emacs Startup by Tweaking the GC Settings (Irreal)
  • Matt Maguire: Ergonomic Emacs
  • Rahul Juliato: Emacs Solo: A Surprise System Crafters Live Demo (HN)
• Emacs Lisp:
  • Emacs Introspection and Debugging (@dliden@fosstodon.org)
  • Get Emacs Packages from the Emacswiki with a Script (02:45)
  • Ep636 emacs lisp, change bracket type, design of function arguments (01:16:25)
• Appearance:
  • Tip: pulsar-mode, pulsar-recenter-center
  • Emacs: Increase text size and adjust window width proportionally. — paste.sr.ht (@jasalt@fosstodon.org)
  • James Cherti: Emacs: persist-text-scale.el – Persist and Restore the Text Scale for All Buffers (Github, Reddit)
  • Marie K. Ekeberg: Emacs Quick Tip - Smoother scrolling (Irreal)
  • Amit Patel: Emacs Tree-sitter custom highlighting, part 3
• Org Mode:
  • The TAB Key in Org Mode, Reimagined (Reddit)
  • Sacha Chua: Org Mode: Cutting the current list item (including nested lists) with a speed command
  • trevdev/org-invoice-table: A clocktable for Emacs org-mode that helps you invoice clients - Codeberg.org (@trevdev@fosstodon.org)
  • TIL you can combine full-text search and tag-matching in the Org agenda
  • Useful library for printing a simplified AST for an org file abstract syntax tree
  • How to contribute patches to Org
  • Import, export, and integration:
    • tiny-rss: A simple and flexible RSS feeds generator from org files
    • Literate Programming for the 24½ Century (2024, this time on Howard Abrams' channel)
    • Sacha Chua: Tweaking my 11ty blog to link to the Mastodon post defined in an Org Mode property
    • Org-Dex: Capture + Archive Browser Sessions
    • Sharing: paw now supports notion style of comment but with org-mode and other goodies
  • Org development:
    • oc-basic.el: New option org-cite-basic-complete-key-crm-separator
    • org-preview-latex-process-alist: Add xelatex support for latex preview
    • Capitalize JavaScript correctly
    • Ensure that gnus-other-frame-object is alive before selecting
• Denote:
  • Protesilaos Stavrou: Emacs: Denote ‘query links’ (links that trigger a search)
  • Protesilaos Stavrou: Emacs: ‘denote-journal’ integration with ‘M-x calendar’
  • Jack Baty: Using the Obsidian Web Clipper with Denote
• Completion:
  • Activate superword mode in the Emacs Minibuffer #coding #programming (01:07) treat symbols (ex: example_symbol as words)
  • [ANN] repeat-fu for repeating multi-command "edits" now available on MELPA (Reddit)
  • Emacs company-mode タイピングが楽になる！！ (無音) (01:50)
• Coding:
  • magit-blame-color-by-age: color-code magit-blame headers by their age
• Math:
  • "Simple Emacs Spreadsheet" a.k.a SES (Reddit)
• Web:
  • Srijan Choudhary: 2025-03-24-002
• Mail, news, and chat:
  • Jack Baty: Mu4e transient menu
  • Gnus for Noobs: Mail and News in Emacs - System Crafters Live! (01:40:19)
  • Listful Andrew: Atomizer — Make Atom feeds for your site (Emacs package)
  • mastodon.el 2.0.0: encrypted auth tokens, fixes, cycling images (@mousebot@todon.nl)
  • Sacha Chua: mastodon.el: Collect handles in clipboard (Emacs kill ring)
  • Sacha Chua: mastodon.el: Copy toot content as Org Mode
  • Benjamin Slade: Trials and Visions of Internet Relay Chat
• Evil mode:
  • 왜 C-d 키를 눌러 스크롤하면 절반 이상이 넘을까? - (emacsian ohyecloudy) (@ohyecloudy@mastodon.social) - evil and scrolling
• Multimedia:
  • Emacs lisp function to update exif data in film scans | Baty.net (@jbaty@social.lol)
  • chordpro-mode.el v2.5.0 release (Reddit
  • fretboard.el – guitar fretboard visualization tool for Emacs (Reddit, HN)
• AI:
  • Ten Dollar Adventure Blog - Automating Interactive Fiction Logic Generation with LLMs in Emacs HN
  • James Dyer: Ollama-Buddy 0.9.11: Experimental ChatGPT Integration, Customizable Streaming and Texinfo documentation
  • Accidentally writing an Emacs Package - fabric-gpt
  • Ollama Buddy - Same prompt to 10 models (multishot) #emacs #ollama (01:27)
• Community:
  • Ramin Honary: Emacs fulfills the UNIX Philosophy (overview) (@amoroso@fosstodon.org)
  • Emacs for Everything (@fnat@social.coop)
• Other:
  • My new Emacs (and Ruby) based Static Site Generator (@mms@mastodon.bsd.cafe)
  • James Cherti: Emacs: bufferfile.el – Delete or rename buffer file names with their associated buffers (Github, Reddit)
  • James Cherti: Emacs: stripspace.el – Automatically Remove Trailing Whitespace Before Saving a Buffer, with an Option to Preserve the Cursor Column
  • trope-mode
  • Emacs Macros: All You Need to Know #coding #programming (15:37) - keyboard macros
  • Clojure visual-tools 32- Workflow Demos 6: old-school tools, REPL, Emacs, Org-mode, AI, MCP, & more (01:51:40)
• Emacs development:
  • emacs-devel: A few explanations. I wonder where a good place to link to these would be; not quite news, but might be good to keep findable since emacs-devel search can be challenging
    • Why replace-region-contents is being deprecated
    • Why there's no built-in function to check if a variable has been changed (helpful has helpful–original-value-differs-p)
    • Why unintern has a mandatory argument
  • Don't obsolete the command replace-buffer-contents
  • Merge remote-tracking branch 'origin/scratch/replace-region-contents'
  • (replace-region-contents): Improve and promote (bug#76313)
  • Enhance 'icomplete-vertical-mode' customization options.
  • New function 'hash-table-contains-p'
  • New minor mode: `electric-block-comment-mode'
  • New Eldoc function `eldoc-show-help-at-pt'
  • Add major mode for highlighting npmrc files (Bug#77138)
  • Help find-function find methods defined inside macros
  • Further amendments of child frame handling and documentation
  • * lisp/treesit-x.el: New file.
• New packages:
  • citar-org-node: Citar integration with org-node (MELPA)
  • denote-regexp: Compose regexps to match Denote files (MELPA)
  • forge-llm: LLM integration for generating PR descriptions in Forge (MELPA)
  • magit-ido: Support using Ido in Magit (MELPA)
  • org-invoice-table: Invoicing table formatter for org-mode (MELPA)
  • repeat-fu: Minor mode to repeat typing or commands (MELPA)
  • stripspace: Auto remove trailing whitespace and restore column (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, 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.

The stripspace Emacs package provides stripspace-local-mode, which automatically removes trailing whitespace and blank lines at the end of the buffer when saving.

(Trailing whitespace refers to any spaces or tabs that appear at the end of a line, beyond the last non-whitespace character. These characters serve no purpose in the content of the file and can cause issues with version control, formatting, or code consistency. Removing trailing whitespace helps maintain clean, readable files.)

It also includes an optional feature (stripspace-only-if-initially-clean, disabled by default), which, when enabled, ensures that trailing whitespace is removed only if the buffer was initially clean. This prevents unintended modifications to buffers that already contain changes, making it useful for preserving intentional whitespace or avoiding unnecessary edits in files managed by version control.

Installation 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 stripspace from MELPA:

(use-package stripspace
  :ensure t
  :commands stripspace-local-mode

  ;; Enable for prog-mode-hook, text-mode-hook, prog-mode-hook
  :hook ((prog-mode . stripspace-local-mode)
         (text-mode . stripspace-local-mode)
         (conf-mode . stripspace-local-mode))

  :custom
  ;; The `stripspace-only-if-initially-clean' option:
  ;; - nil to always delete trailing whitespace.
  ;; - Non-nil to only delete whitespace when the buffer is clean initially.
  ;; (The initial cleanliness check is performed when `stripspace-local-mode'
  ;; is enabled.)
  (stripspace-only-if-initially-clean nil)

  ;; Enabling `stripspace-restore-column' preserves the cursor's column position
  ;; even after stripping spaces. This is useful in scenarios where you add
  ;; extra spaces and then save the file. Although the spaces are removed in the
  ;; saved file, the cursor remains in the same position, ensuring a consistent
  ;; editing experience without affecting cursor placement.
  (stripspace-restore-column t))

Features

Here are the features of (stripspace-local-mode):

• Before saving buffer: Automatically removes all trailing whitespace.
• After saving buffer: Restores the cursor’s column position on the current line, including any spaces before the cursor. This ensures a consistent editing experience and prevents unintended cursor movement when saving a buffer and removing trailing whitespace. This behavior can be controller by the stripspace-restore-column variable (default: t).
• Even if the buffer is narrowed, stripspace removes trailing whitespace from the entire buffer. This behavior, controlled by the stripspace-ignore-restrictions variable (default: t).
• An optional feature stripspace-only-if-initially-clean (default: nil), which, when set to non-nil, instructs stripspace to only delete whitespace when the buffer is clean initially. The check for a clean buffer is optimized using a single regex search for trailing whitespace and another for blank lines.
• The stripspace-verbose variable, when non-nil, shows in the minibuffer whether trailing whitespaces have been removed or, if not, provides the reason for their retention.
• The functions for deleting whitespace are customizable, allowing the user to specify a custom function for removing trailing whitespace from the current buffer.
• The stripspace-clean-function variable allows specifying a function for removing trailing whitespace from the current buffer. This function is called to eliminate any extraneous spaces or tabs at the end of lines. (For example, this can be set to a built-in function such as delete-trailing-whitespace (default) or whitespace-cleanup.)

Links

• stripspace.el @GitHub
• stripspace.el @MELPA

I just made it possible for users of my denote-journal package to interact with the M-x calendar as part of their journaling workflow.

Highlight dates with a Denote journal entry

The new minor mode denote-journal-calendar-mode highlights dates in the M-x calendar which have a corresponding Denote journal entry. The applied face is called denote-journal-calendar: I made it draw only a box around the date, thus respecting existing colouration. Here is a demonstration, which also includes red-coloured dates for holidays:

The denote-journal-calendar-mode is buffer-local and meant to be activated inside the M-x calendar buffer, thus:

(add-hook 'calendar-mode-hook #'denote-journal-calendar-mode)

View the journal entry for the current date

While navigating the calendar buffer, use the command denote-journal-calendar-find-file to visit the Denote journal entry corresponding to the date at point. If there are multiple journal entries, the command will prompt you to select one among them.

Create or view journal entry for the current date

The command denote-journal-calendar-new-or-existing creates a new journal entry for the date at point or visits any existing one. This is like denote-journal-new-or-existing-entry but for the given M-x calendar date.

Part of development

Remember that I have split denote into several packages, one of which is denote-journal. I plan to coordinate the release of new versions across all Denote-related packages, so expect the aforementioned to be available at around the same time as denote version 4.0.0 (which is going to be massive, by the way).

About Denote journal

The denote-journal package makes it easier to use Denote for journaling. While it is possible to use the generic denote command (and related) to maintain a journal, this package defines extra functionality to streamline the journaling workflow.

The code of denote-journal used to be bundled up with the denote package before version 4.0.0 of the latter and was available in the file denote-journal-extras.el. Users of the old code will need to adapt their setup to use the denote-journal package. This can be done by replacing all instances of denote-journal-extras with denote-journal across their configuration.

• Package name (GNU ELPA): denote-journal
• Official manual: https://protesilaos.com/emacs/denote-journal
• Git repository: https://github.com/protesilaos/denote-journal
• Backronym: Denote… Journaling Obviously Utilises Reasonableness Notwithstanding Affectionate Longing.

About Denote

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

The bufferfile Emacs package provides helper functions to delete and rename buffer files:

• bufferwizard-rename-file: Renames the file that the current buffer is visiting. This command renames the file name on disk, adjusts the buffer name, and updates any indirect buffers or other buffers associated with the old file.
• bufferwizard-delete-file: Delete the file associated with a buffer and kill all buffers visiting the file, including indirect buffers.

Installation with straight (Emacs version < 30)

To install bufferfile with straight.el:

1. It if hasn’t already been done, add the straight.el bootstrap code to your init file.
2. Add the following code to the Emacs init file:

(use-package bufferfile
  :ensure t
  :straight (bufferfile
             :type git
             :host github
             :repo "jamescherti/bufferfile.el"))

Alternative installation: Installation with use-package and :vc (Built-in feature in Emacs version >= 30)

To install bufferfile with use-package and :vc (Emacs >= 30):

(use-package bufferfile
  :ensure t
  :vc (:url "https://github.com/jamescherti/bufferfile.el"
       :rev :newest))

Customization: Making bufferwizard use version control (VC), such as Git, when renaming or deleting files?

To make bufferwizard use version control (VC) when renaming or deleting files, you can set the variable bufferfile-use-vc to t. This ensures that file operations within bufferwizard interact with the version control system, preserving history and tracking changes properly.

(setq bufferfile-use-vc t)

Links

• bufferfile.el @GitHub

I’ve written a couple of times about Álvaro Ramírez’s Journelly [1, 2] and how it seemed like a good fit for my memo book needs. In the last of those posts, Ramírez announced that he was starting an official beta program. I wrote that I might sign up but as usual inertia prevailed and I didn’t get around to it.

In his latest post on Journelly, Ramírez notes that Mac Observer has a review of Journelly. I hopped over there to take a look and was impressed. It’s a nice review and makes Journelly seem like an even better fit for my needs than I had previously thought. If you’re the slightest bit interested in Journelly or think you might be, you should definitely take a look at the Mac Observer review.

Ramírez’s posts on Journelly tend to emphasize it’s use as a sort of private Twitter/X but the Mac Observer review makes clear that it can also be used as a kind of journaling app as well. One of the best parts, from my point of view, is that the data is saved in Org mode format so I should be able to integrate it into my Emacs workflow easily.

In any event, I was finally able to bestir myself to email Ramírez and ask for a beta invite. He responded right away with my invite and I installed it without a problem. I’ve never participated in an iOS beta before and wasn’t sure how to get the beta app installed. It turns out to be easy. Apple has a special app called TestFlight that automates everything. You simply install TestFlight, click on the invite, and everything else happens automatically.

I just finished the install and haven’t had time to play with Journelly yet but I’ll let you know what I think as soon as I get a bit of experience with it.

Upgrading Emacs is always a project, especially on macOS.

I’ve been using Emacs Plus on my Mac since I installed version 28, but when I went to update to version 30.1 through homebrew, I got a cryptic git error. From the little research I did, it has to do with commits being in the wrong place. The explanation was something that went over my head, so I shrugged it off and tried Emacs for macOS again. I forget what was the reason this Emacs flavor wasn’t for me in the past, but it seems to work fine now. Well, after I deleted and reinstalled marginalia, exactly as Irreal mentioned. Seems to be working fine now.

I was excited about completion-preview-mode (if Mickey is raving about something, you got to check it out), but so far, in my experience, it’s just “meh,” at least out of the box. After I got it to work in org-mode (the manual is a bit of a mess and seems to be thrown into the package itself, but I found out what to do in this YouTube video) it’s not much better than what company-mode gives me at the moment, so I’m going to wait until someone probably comes around with “actually, it’s much better because X, and you can find out how to do it over at Y,” or Mickey writes something more complete. The video I mentioned goes into some helpful examples, but I get lost in terms of how to set it up in my case.

Then, again per Mickey, There’s “The Org URI protocol should now register automatically, meaning you can send data from a browser bookmarklet straight into org capture in your running Emacs instance.” I remember I once got it (or something similar) to work with org protocol, but a native option turned on like this seems very good, and I’d love to be able to send text and links from my browser directly to Emacs. I’m not sure how to get this to work either. I recall I need to run Emacs as a server in the background and then launch Emacs as a client, but this is beyond my current macOS kung fu. The issue with finding how is usually knowing what to look for. I need to be more specific about my research, but i’m not sure what it is I’m looking for.

Upgrading Emacs is always rewarding because I also get to upgrade my brain with it. I learn how to do new things, and do them more effectively. I’m sure I’ll be back at tweaking pretty soon.

Defining shortcuts in org-speed-commands is handy because you can use these single-key shortcuts at the beginning of a subtree. With a little modification, they'll also work at the beginning of list items.

(defun my-org-use-speed-commands-for-headings-and-lists ()
  "Activate speed commands on list items too."
  (or (and (looking-at org-outline-regexp) (looking-back "^\**" nil))
      (save-excursion (and (looking-at (org-item-re)) (looking-back "^[ \t]*" nil)))))
(setq org-use-speed-commands 'my-org-use-speed-commands-for-headings-and-lists)

I want k to be an org-speed-commands that cuts the current subtree or list item. This is handy when I'm cleaning up the Mastodon toots in my weekly review or getting rid of outline items that I no longer need. By default, k is mapped to org-cut-subtree, but it's easy to override.

(defun my-org-cut-subtree-or-list-item (&optional n)
  "Cut current subtree or list item."
  (cond
   ((and (looking-at org-outline-regexp) (looking-back "^\**" nil))
    (org-cut-subtree n))
   ((looking-at (org-item-re))
    (kill-region (org-beginning-of-item) (org-end-of-item)))))
(with-eval-after-load 'org
  (setf (alist-get "k" org-speed-commands nil nil #'string=)
        #'my-org-cut-subtree-or-list-item))

So now, if I put my cursor before "1." below and press k:

- this
  1. is a
    - nested
  2. list
- with levels

it will turn into:

• this
  1. list
• with levels

You can find out a little more about Org Mode speed commands in the Org manual: (info "(org) Speed Keys").

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

I don't know about you, but when I'm reading something in an Org file and spot a link I want to follow, I instinctively press TAB to jump to it—just like I would in an Info or Help buffer. Using TAB for such field navigation is a common pattern across many applications, including Emacs. It’s also nicely symmetric with Shift-TAB (S-TAB), which typically navigates backward. But in Org mode, TAB triggers local visibility cycling: folding and unfolding text under the current headline. S-TAB cycles visibility globally, folding and unfolding all the headlines. (Granted, if you don’t use Info or navigate Help buffers with TAB, you might not miss that behavior in Org mode.)

See, we have this dichotomy in Org mode: it's both an authoring tool and a task/notes manager. For document authoring, Org markup serves as a source format that's later exported for publishing. In this context, visibility cycling is essential for managing structure and reducing distractions while writing. As a task and notes manager, Org is used to track notes, TODO lists, schedules, and data—content that's often read in place and never exported. Visibility cycling still helps, but it's generally less critical than in authoring mode.

This reading workflow within Org files makes me long for features found in more reading-focused modes. Sure, I don’t treat my Org files as read-only; reading and editing are fluidly intertwined. Still, when I'm focused on reading, I want the TAB key to handle navigation, not headline visibility cycling. And I don't want to switch to another mode like View mode just to get a better reading experience.

It's well known that the TAB key is heavily overloaded in Emacs, especially in Org mode. Depending on context and configuration, it can perform one of four types of actions: line indentation, candidate completion (during editing), or field navigation and visibility cycling (during reading). As mentioned earlier, TAB is commonly used for field navigation in Info and Help modes. But note that even Org mode uses it this way within tables. Its association with visibility cycling was unique to Org mode until recently, when it was made an option in Outline mode too.

Personally, I want to move in the opposite direction: removing visibility cycling from the list of TAB-triggered actions. Three types of behavior are already plenty. I'd rather assign visibility control to a more complex keybinding and prioritize field navigation instead. I'm not a big fan of cycling in general (see my previous blog post), and would prefer to jump directly to specific folding levels. I also value consistency in keybindings, so unifying TAB behavior across modes is important to me.

TAB: indentation and completion when editing; field navigation when reading

I decided to give it a try and remap TAB in Org mode to primarily perform field navigation. What exactly is considered a “field” is largely up to the user. In general, it should be a structural element in a file where a non-trivial action can be performed, making it useful to have an easy way to jump between them. For my setup, I chose to treat only links and headlines as fields, similar to how Info handles navigation. Of course, others might include property drawers, code blocks, custom buttons, or other interactive elements. I wouldn't overdo it though—too many fields and TAB navigation loses its utility.

I remapped TAB in Org mode to navigate to the next visible heading or link, and S-TAB to move to the previous one. Headlines and links inside folded sections are skipped. For visibility cycling, I now rely on Org Speed Keys (a built in feature of Org mode).

Speed Keys let you trigger commands with a single keystroke when the point is at the beginning of a headline. They’re off by default but incredibly handy once enabled. A number of keys are predefined out of the box; for example, c is already mapped to org-cycle, which is what TAB normally does in Org mode.

I’ve had Speed Keys enabled for ages (mainly using them for forward/backward headline navigation), but I had never used c for visibility cycling—until now. And it gets even better: the combination of TAB / S-TAB to jump between fields, followed by a speed key at the headline, turns out to be quite powerful.

What about the other actions TAB usually performs in Org files? For now, I rely on M-x org-cycle when needed. The org-cycle command is quite sophisticated and can fall back to other TAB behaviors like indentation when appropriate. That said, I’ve been using my custom TAB / S-TAB bindings for months now and haven’t run into any situations where I missed the default behavior.

Want to give it a try? Here’s the code you can drop into your init.el:

(defun /org-next-visible-heading-or-link (&optional arg)
  "Move to the next visible heading or link, whichever comes first.
With prefix ARG and the point on a heading(link): jump over subsequent
headings(links) to the next link(heading), respectively.  This is useful
to skip over a long series of consecutive headings(links)."
  (interactive "P")
  (let ((next-heading (save-excursion
                        (org-next-visible-heading 1)
                        (when (org-at-heading-p) (point))))
        (next-link (save-excursion
                     (when (/org-next-visible-link) (point)))))
    (when arg
      (if (and (org-at-heading-p) next-link)
          (setq next-heading nil)
        (if (and (looking-at org-link-any-re) next-heading)
            (setq next-link nil))))
    (cond
     ((and next-heading next-link) (goto-char (min next-heading next-link)))
     (next-heading (goto-char next-heading))
     (next-link (goto-char next-link)))))

(defun /org-previous-visible-heading-or-link (&optional arg)
  "Move to the previous visible heading or link, whichever comes first.
With prefix ARG and the point on a heading(link): jump over subsequent
headings(links) to the previous link(heading), respectively.  This is useful
to skip over a long series of consecutive headings(links)."
  (interactive "P")
  (let ((prev-heading (save-excursion
                        (org-previous-visible-heading 1)
                        (when (org-at-heading-p) (point))))
        (prev-link (save-excursion
                     (when (/org-next-visible-link t) (point)))))
    (when arg
      (if (and (org-at-heading-p) prev-link)
          (setq prev-heading nil)
        (if (and (looking-at org-link-any-re) prev-heading)
            (setq prev-link nil))))
    (cond
     ((and prev-heading prev-link) (goto-char (max prev-heading prev-link)))
     (prev-heading (goto-char prev-heading))
     (prev-link (goto-char prev-link)))))

;; Adapted from org-next-link to only consider visible links
(defun /org-next-visible-link (&optional search-backward)
  "Move forward to the next visible link.
When SEARCH-BACKWARD is non-nil, move backward."
  (interactive)
  (let ((pos (point))
        (search-fun (if search-backward #'re-search-backward
                      #'re-search-forward)))
    ;; Tweak initial position: make sure we do not match current link.
    (cond
     ((and (not search-backward) (looking-at org-link-any-re))
      (goto-char (match-end 0)))
     (search-backward
      (pcase (org-in-regexp org-link-any-re nil t)
        (`(,beg . ,_) (goto-char beg)))))
    (catch :found
      (while (funcall search-fun org-link-any-re nil t)
        (let ((folded (org-invisible-p nil t)))
          (when (or (not folded) (eq folded 'org-link))
            (let ((context (save-excursion
                             (unless search-backward (forward-char -1))
                             (org-element-context))))
              (pcase (org-element-lineage context '(link) t)
                (link
                 (goto-char (org-element-property :begin link))
                 (throw :found t)))))))
      (goto-char pos)
      ;; No further link found
      nil)))

(defun /org-shifttab (&optional arg)
  "Move to the previous visible heading or link.
If already at a heading, move first to its beginning.  When inside a table,
move to the previous field."
  (interactive "P")
  (cond
   ((org-at-table-p) (call-interactively #'org-table-previous-field))
   ((and (not (bolp)) (org-at-heading-p)) (beginning-of-line))
   (t (call-interactively #'/org-previous-visible-heading-or-link))))

(defun /org-tab (&optional arg)
  "Move to the next visible heading or link.
When inside a table, re-align the table and move to the next field."
  (interactive)
  (cond
   ((org-at-table-p) (org-table-justify-field-maybe)
    (call-interactively #'org-table-next-field))
   (t (call-interactively #'/org-next-visible-heading-or-link))))

(use-package org
  :config
  ;; RET should follow link when possible (moves to next field in tables)
  (setq org-return-follows-link t)
  ;; must be at the beginning of a headline to use it; ? for help
  (setq org-use-speed-commands t)
  ;; Customize some bindings
  (define-key org-mode-map (kbd "<tab>") #'/org-tab)
  (define-key org-mode-map (kbd "<backtab>") #'/org-shifttab)
  ;; Customize speed keys: modifying operations must be upper case
  (custom-set-variables
   '(org-speed-commands
     '(("Outline Navigation and Visibility")
       ("n" . (org-speed-move-safe 'org-next-visible-heading))
       ("p" . (org-speed-move-safe 'org-previous-visible-heading))
       ("f" . (org-speed-move-safe 'org-forward-heading-same-level))
       ("b" . (org-speed-move-safe 'org-backward-heading-same-level))
       ("u" . (org-speed-move-safe 'outline-up-heading))
       ("j" . org-goto)
       ("c" . org-cycle)
       ("C" . org-shifttab)
       (" " . org-display-outline-path)
       ("s" . org-toggle-narrow-to-subtree)
       ("Editing")
       ("I" . (progn (forward-char 1) (call-interactively 'org-insert-heading-respect-content)))
       ("^" . org-sort)
       ("W" . org-refile)
       ("@" . org-mark-subtree)
       ("T" . org-todo)
       (":" . org-set-tags-command)
       ("Misc")
       ("?" . org-speed-command-help))))
  )

A few comments about the code, for those interested:

1. This is more of a proof-of-concept than optimized code ready for upstreaming.
2. My /org-next-visible-link is a simplified version of the built-in org-next-link, tailored to the specific cases I care about. Honestly, I was surprised that org-next-link doesn’t already do what I need. It jumps to the next link even if it’s inside a folded section, causing it to unfold. I have a hard time imagining why would anyone need that.
3. In /org-tab and /org-shifttab, I preserved the default behavior of org-cycle within a table: it navigates between table fields.
4. I’ve also customized org-speed-commands to only bind editing actions to keys that require the Shift modifier. I like keeping lowercase keys reserved for non-destructive commands. As a next step, I may remap Space and Shift-Space to scroll the buffer. That would bring me even closer to a more consistent reading experience.

Enjoy the malleability of Emacs and the freedom it gives you!

Discuss this post on Reddit.

Bozhidar Batsov has posted another in his long list of informative Emacs posts. This time, it’s about configuring Emacs garbage collection. The principal way of doing that is to set gc-cons-threshold to a higher value than its default of 80000. Batsov has his set to 50000000 and is wondering if he should increase it.

On the other hand, picking a correct value is far from trivial. Batsov includes some text from Eli Zaretskii, the current Emacs maintainer, that says setting the value too high will adversely affect performance.

Garbage collection is notoriously difficult to configure correctly in any application and I have no special insight into what the correct value should be in any particular situation. What I can do, though, is tell you what I do, which works very well for me. I virtually never see a pause for garbage collection. On the other hand, I don’t invoke a lot of memory hungry functions so my results may differ from yours.

I long ago gave up tweaking gc-cons-threshold and installed gcmh to handle garbage collection for me. Gcmh is based on the observation that if Emacs has been idle for 15 seconds, it will probably be idle longer so it’s a good time kick off garbage collection. It does this by setting the normal threshold very high but when it sees that Emacs is idle, it sets it to a low value to kick off garbage collection. The explanation of how it works is here.

Gcmh tells you every time it kicks off garbage collection and I frequently see this when I stop typing for a bit. The system works really well for me. As I say, I never see a delay for garbage collection. If you’re seeing problems in that area, give gcmh a try and see how it works for you.

I ran across something neat while reading the Mu4e release notes

A (experimental) “transient” menu has been added for mu4e. You can use it e.g., with something like:

(require 'mu4e-transient)
(global-set-key (kbd "C-c m") #'mu4e-transient-menu)

It’s very handy!

Recently I was wondering whether I should move on from Doom Emacs/Evil Mode and try a less opinionated setup based on more traditional key mappings. I was looking around for some sort of “starter kit” that provides some basic features that I have grown accustomed to using Doom Emacs. Some of the options I looked at were:

• Xah Lee’s Sample Init File from his online tutorial. This is a name I have come across a number of times as I research Emacs, and I believe he also has a large collection of YouTube videos on the topic. The config is very basic, and doesn’t include any packages. It would take some time for me to work out how to implement features such as syntax highlighting, completion, etc. which, while very educational, is a bigger time commitment than I can currently afford.

This was meant to be a shortish bit on a couple of points on a decent IRC (Internet Relay Chat) set-up, including:

• some sort of persistence (a “bouncer” or the always-connected server)
• use with some sort of IRC client in Emacs
• some sort of reasonable mobile phone client

It ended up longer than I intended.

tldr

• Using some of the more IRCv3 tools, particularly the cluster of things by Simon Ser and co (soju, goguma, gamja - see below) makes for a much better IRC experience, and easily supports synchronised access across multiple devices (e.g., desktop, laptops, mobile).
  • soju provides a very capable bouncer
  • goguma provides an excellent mobile client
  • gamja is a very user-friendly web-client front-end
  • and these three things can complement each other in a complete IRC setup system
• we can make such a soju-based set-up work well with Emacs IRC clients
• soju and gamja can be self-hosted; but there are also two paid/hosted instances currently available:
  • SourceHut’s chat.sr.ht (on a fork of soju with a different feature-set)
  • IRC Today’s service (I think closer to mainline soju, but not certain)
• we can leverage some of the IRCv3 functions nicely in Emacs

The most useful bits here may be notes on how to set up clients to work with SourceHut’s chat.sr.ht, particularly Goguma and Emacs/ERC, and some of the cool features of IRCv3 things [modernising IRC], like the soju bouncer (which is used by chat.sr.ht), for which see the section below “Smooth & Modern IRC Implementation & Practice (mobile, Emacs)", which you might jump to if you don’t want to read a bunch of preamble.

History, theory, background

Pre-history: wee chats in musl pies

Long ago now I spent a while setting up a RaspberryPi 3b (running musl flavoured Void Linux) as a Weechat Server/Bouncer in order to make using IRC less painful. This involved a lot of steps, including setting up a NoIP script and SSL certs with Let’s Encrypt, and setting up scripts to auto-fetch new certs. But once up, it worked well (unless my home internet went out), and Weechat had a nice mobile app, so I could connect both on desktop/laptop with an Emacs IRC client and also had a pocket connection via my mobile phone ¹. This gave me a persistent connection and log history and all that.

Then I started using Matrix (=a modern, but heavy, “IRC replacement”, itself theoretically a Slack, Discord, &c. competitor) more, (in part) since some projects have chosen it as a more modern/capable alternative to IRC, and, soon after, it was the case that most of the IRC rooms I was in were bridged to Matrix anyway. And then it seemed perhaps more convenient just to access everything in one place, since some things were only Matrix and not on IRC, it made sense for that to be Matrix.

And then the Matrix bridges mostly shut down.

Path of the prodIRCal son

I toyed off and on with getting re-set up on IRC, but there has been a lot of other things going on in life, and I didn’t feel like trying to set up my rpi mini-server IRC bouncer again.

I tried some other hosted IRC bouncer services. But some of these wouldn’t let me connect with on a VPN.

I found one good free (as in freedom and free as in no paisa) ZNC bouncer service, which is FreeIRC.org ²

The ZNC bouncer worked fine on Emacs (with ERC; I’ve gone back and forth between ERC and Circe, but this time I was trying ERC again).³ And I eventually figured out how to connect to multiple networks through the ZNC bouncer.

But the best thing I could find on mobile was the Revolution IRC client, and, while it’s a nice enough front-end, it struggled with maintaining a connection to the ZNC bouncer I was using. (I asked about this in an IRC room, and the general consensus was that mobile’s just not a good place to try to do IRC, but I remembered that via the Weechat android app or through Glowing Bear I’d had a good mobile IRC experience years ago.)

IRCv3, and other Korean tubers

I also came across another IRC mobile app, Goguma, but couldn’t get it work. But, frustrated with the situation, I wanted to see if, assuming I could somehow get it work, Goguma might be a better mobile solution.⁴

I ultimately ended up stumbling across an interesting lobste.rs discussion of Goguma which pointed to it being part of a set of IRCv3-aware software, including an IRC bouncer soju, which a number of the commenters on the lobste.rs thread comparing the experience favourably against using ZNC.

A cluster of IRCv3 things:⁵

• Goguma (Korean 고구마 goguma “sweet potato”): IRC mobile client written in Flutter by Simon Ser
• Gamja (Korean 감자 gamja “potato”): simple IRC web client written in Javascript by Simon Ser
• Soju (Korean 소주 soju “a distilled alcoholic beverage”): IRC bouncer written in Go by Simon Ser
• Senpai (Japanese 先輩 sèńpáí “senior in social standing or level of education/skill; an elder”): a modern terminal IRC written in Go, started by ‘taiite', who handed development over to ‘delthas'.
• Ergo (a play on ergonomic [and “ergonomadic"] and Go(lang), so I suppose ultimately from Ancient Greek ἔργον érgon “work”, but not sure that’s relevant): a modern IRC server written in Go [Jeremy Latt, Daniel Oaks, Shivaram Lingamneni] implementing bleeding-edge IRCv3 features/support

The first three things are the most relevant for us (well, me). Ergo sounds great, but I’m not running an IRC server myself at the moment; and I’ve got a whole wealth of choices of Emacs IRC clients if I’m on desktop/laptop, so Senpai doesn’t seem relevant either for my use case.

Trains, Wayland, and Things that Go

The first three of the IRCv3-looking things are all by Simon Ser, who was lately at Drew DeVault‘s SourceHut, but seems to have left sometime in 2024⁶ and now works at Open Source Railway Designer (something to do with making tools for railway infrastructure simulation, which sounds quite cool: open source trains). Ser obviously works a good bit on IRC-related software, and also a lot of things in Go, and has been involved with Wayland-related projected (taking over maintainership of Sway (a Wayland window manager) and wlroots (Wayland general purpose compositor underlying Sway and other things) from DeVault some years back).

Here’s Thomas Flament & Simon Ser talking about IRCv3 and soju, senpai, gamja, goguma at FOSDEM ‘25 in Brussels:

Chatting on IRC in 2025: grandpa, what’s up? [video link with captions]

In any case, one of the paid-only features that SourceHut offers is via chat.sr.ht, an IRC bouncer, which is running on a fork of soju, with a web-client based on gamja.

As far as I can tell, Sourcehut’s servers are now (all? mainly?) in Amsterdam.⁷

chat.sr.ht isn’t the only hosted IRC bouncer service which runs some version of the soju bouncer, there is also IRC Today [discussed also on lobste.rs], which is hosted in Paris on Scaleway servers.⁸

So, there are at least two apparently EU-based hosted “IRCv3-forward” bouncers.

Smooth & Modern IRC Implementation & Practice (mobile, Emacs)

How to manage to drink rice liquor in a hut: preliminaries

In any case, I signed up for the SourceHut offering at chat.sr.ht, which uses their fork of soju.

Here’s what I did to get it set up for mobile and in Emacs (it seemed worth documenting, in what was meant to be a short post….):

The main things one needs to know are in the chat.sr.hut ‘manpages’, especially the ‘quickstart guide’. But here are a few more notes for specific set-up on Goguma and Emacs.

The first thing one needs to do for any “third-party” client (this includes Goguma or any Emacs IRC client) is generate an OAuth 2.0 personal access token in your SourceHut account. This will be effectively your “password” (with your SourceHut login name as your username).

Nb: on mobile, you have to be careful to actually manage to copy the entire token with “Select all” or the like - I was stuck for a long time not being able to make Goguma work because I’d not managed to copy the entire token, and this wasn’t at all obvious in a mobile browser. On desktop, it’s not an issue.

Goguma (mobile): One potato, two potato, sweet potato

For Goguma, you’re just going to put in:

• Server: chat.sr.ht
• Nickname: <your SourceHut username>
• Password: <an OAuth2.0 token you generated as above>

And you’re in. And here’s what it looks like:

And there’s a setting in Goguma (“Compact message list”) to make it look less like a mobile messaging app and just have plain text if you prefer that:

And you can have Goguma show you notifications if someone mentions your nick. Here is an example showing on a Pebble watch:

(IRC on one’s wrist; it truly is 2025.)

Emacs machines and authority tokens: what to put in your authinfo.gpg and init.el

In your ~/.authinfo.gpg file, add a line like this (with <>‘ed items to be replaced fully; don’t actually include any <>'s here or above or elsewhere; where "my-sourcehut-id" is your actual sourcehut login id in quotes):

machine chat.sr.ht login "my-sourcehut-id" password "<one of your OAuth 2.0 tokens generated at SourceHut meta>"

And then in your ~.emacs.d/init.el, assuming you’re using ERC and have that configured otherwise to your liking, make a user-function for each actual IRC server you want to connect with via chat.sr.ht/soju, like this (assuming your user-id is "my-sourcehut-id": replace appropriately— and you might have different :nick's (“nicknames” ≈ user-handles/user-names/identities) on different servers, of course, so adjust those as well; but your :username is going to be consistently your SourceHut username followed by “/<the-particular-irc-server-address>"):

;; just so we don't have to type it each time, a wrapping `let',
;; and so after this our `server', `port', & `passwd' will be thus defined
;; (you could do `:nick' like this too if it's the same everywhere)
(let ((server "chat.sr.ht")
      (port 6697)
      (passwd
       (cadr
        (auth-source-user-and-password "chat.sr.ht" "my-sourcehut-id"))))
  ;; `auth-source-user-and-password' returns a list of `login' and `password'
  ;; from your .authinfo.gpg; but we just need the second, so `cadr' (= return
  ;; the `car' of the `cdr'), because since the list is going to be something
  ;; like `(mylogin mypassword)', will give us just the atomic `mypassword',
  ;; which is what we want [because the `cdr' of `(mylogin mypassword)' will be
  ;; `(mypassword)' and the `car' of `(mypassword)' will be just `mypassword'].)

  (defun erc-libera ()
    "Connect to Libera.Chat IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc.libera.chat"
     :password passwd))

  (defun erc-oftc ()
    "Connect to OFTC IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc.oftc.net"
     :password passwd))

  (defun erc-ircnow ()
    "Connect to IRCNow IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc6.ircnow.org"
     :password passwd))

  (defun erc-ergo ()
    "Connect to IRCv3-forward Ergo IRC server."
    (interactive)
    (erc-tls
     :nick "emacsuser007"
     :server server
     :port port
     :user "my-sourcehut-id/irc.ergo.chat"
     :password passwd)))

Here we’re making connections for Libera, OFTC, IRCNow, and Ergo, the IRCv3-forward server implemented in Go we mentioned above.⁹

But you can add lots of different servers to your bouncer, and both in Goguma and Emacs/ERC (just make a new erc-<server> function as above), you’ll just be able to get to all of the different rooms in one place and don’t necessary need to worry about which server a particular thing is on after getting it set up.

And then you can make a “connect to all the things function” like this:

(defun erc-connect-all ()
  "Connect to all IRC servers above."
  (interactive)
  ;; we're just calling all of the functions we defined above here:
  (erc-libera)
  (erc-oftc)
  (erc-ircnow)
  (erc-ergo))

And what it looks like (well, it looks like however you’ve configured ERC or whatever Emacs IRC client you’re using, but, in case you want to see a possible way it could look):

If you get knocked offline momentarily, ERC will try to reconnect to the bouncer. If you are knocked off or close Emacs for a while, you might want to catch up on what you missed recently. And there’s a nice IRCv3 feature implemented in soju (and in chat.sr.ht) for this, as discussed in the next section.

Leveraging IRCv3 features in Emacs

We can also do another convenient thing for our Emacs IRC configuration now. IRCv3 defines a “chathistory” extension, as an easy way of retrieving earlier IRC room content. This doesn’t work most places, but it works on any bouncers based on soju (see notes below), the syntax being /quote CHATHISTORY LATEST <channelname> * <number-of-lines-to-fetch>.

We can make this more user-friendly in Emacs with something like this, an interactive command that fetches history for whatever IRC room it’s called in (a 100 lines by default; prefix C-u to enter a different number):

(defun erc-chatsrht-give-me-more-irc-history ()
  "Get more history for current IRC buffer (IRCv3 only).

Defaults to 100 lines of history; when C-u prefixed, asks user for
number of lines to fetch.

If using an IRCv3 capable server/bouncer (like chat.sr.ht), fetch the
chat history via the IRCv3 chathistory extension. (Currently, only
soju-based servers implement this feature; see:
https://ircv3.net/software/clients)

For more on chathistory, see:
 - https://man.sr.ht/chat.sr.ht/bouncer-usage.md#chat-history-logs
 - https://ircv3.net/specs/extensions/chathistory
 - https://soju.im/doc/soju.1.html"
  (interactive)
  (if (not (member
            (with-current-buffer (current-buffer)
              major-mode)
            '(erc-mode
              circe-mode
              rcirc-mode)))
      (message "not an IRC buffer; ignoring")
    (let ((lines 100)
          (channel (buffer-name)))
      (when current-prefix-arg
        (progn
          (setq lines
                (read-number (format "How many lines to fetch: ") lines))))
      (erc-send-input
       (concat "/quote CHATHISTORY LATEST " channel " * " (number-to-string lines))
       t))))

Then you can just call erc-chatsrht-give-me-more-irc-history in an IRC buffer (you might find a convenient keybinding for it) to get prior IRC chat in that buffer.

This sort of thing makes Emacs a very pleasant environment to manage IRC in.

Now, for actually adding servers to your chat.sr.ht bouncer in the first place, you might try out the gamja web client (see below).

Inline images and files in Goguma and Emacs

Oh. Gamja (as least as implemented by chat.sr.ht) doesn’t seem to do it, but Goguma fetches image links and displays a preview:

[Note: chat.sr.ht’s soju fork doesn’t currently offer direct file-upload and is perhaps unlikely to, but this seems to be implemented in upstream soju and maybe on IRC Today.]

Additional note: Goguma doesn’t do this by default; you need to go into the main “Settings” menu and enable “Display link previews”. (I also have “Send & display typing indicators” turned on here.)

And you can make ERC do similarly, with respect to fetching posted image links, with the erc-image package from MELPA. I have a use-package definition like this:

(use-package erc-image
  :ensure t
  :after erc
  :config
  (setq erc-image-inline-rescale 300) ; maybe set bigger
  (add-to-list 'erc-modules 'image))

And then you’ll see something like this if you post an image link in ERC:

I’d like to figure out how one might better manage it, but — in terms of handling posting local files — there’s a (not-on-MELPA) package imgbb.el which will upload images in Emacs (when passed a file-path or interactively from a file-chooser) to ImgBB, and then put the link in the clipboard.¹⁰

[Note: For better or worse, erc-image will pull images from http as well as https addresses; while Goguma seems only to do the latter.]

Web-client: The sweetness of non-sweet potatoes on the web

The web interface for chat.sr.ht (at https://chat.sr.ht) is, again, based on gamja (“potato”) (discussed above) and gamja is a nice interface indeed.

And, for making your initial connections to different IRC servers, it may be easier just to use this web interface, especially if you’ve already got accounts set up on any of the servers, as for most of them you’ll be able to enter your username and password and so on in the “Add server” interface and not have to do all of the /msg NickServ .... stuff one usually does. (If you don’t have an account already, you’ll have to register in someway, maybe by messaging Nick).

Looks like this:

In fact, even for signing in/up on a brand new server, at least on some servers, gamja lets you click on “login” or “register” and pulls up a pop-up box to fill in password, email, &c. So it’s quite convenient (and you may not have to message Nick manually).

Wrap-up & evaluation

There are interesting IRC things still going on, both in terms of active IRC communities (though this varies; #emacs is quite active, #dwarffortress isn’t; Discord has eaten into some spaces), and innovations in IRC technologies and tools.

I’m not sure what the best thing is terms of choice of a soju/gajma ecosystem. chat.sr.ht seems to be the cheapest hosted option; IRC Today is more expensive but may currently be more featureful. SourceHut has had trouble with being DDOS’ed/going off-line (see, e.g., SourceHut network outage post-mortem).

Self-hosted set-ups are another option, but are likely to be more fiddly/effort to run/maintain than a “professional” service. But here are a few links to descriptions of people’s self-hosted soju setups:

• self-hosting on Alpine Linux: Self-Hosting Soju
• self-hosting on OpenBSD: Setting up an IRC bouncer (soju) on OpenBSD · Hugo’s weblog
• more self-hosting on Alpine Linux: Self-Hosted IRC with Soju & Senpai | Isaac Ganoung’s Website
• self-hosting on IRCNow: IRCNow | Soju / Guide

Currently, chat.sr.ht is working well for me, even if it may be behind on some mainline soju features.

Appendix: etymologies

You probably don’t need to know any of this. It’s not going to help you log into Goguma or make your Emacs config work.

But the naming of a lot of the IRC things above is strange and I’m a linguist by trade and it’s hard for me to avoid paying a lot of attention to words and meanings of words and connections of words.

(While on the topic of mostly irrelevant things: I have some other-language interference (Hindi here) with the Korean names of some of the software discussed here. Specifically, gamja makes me think either गंजा ganjā “bald” or गाँजा gā̃jā “ganja, cannabis”; and soju keeps making me think of an elided version of सो जाऊं so jāū̃ “shall I go to sleep?” [“नहीं! आप आई॰आर॰सी॰ बाउंसर हैं, आपको सो नहीं जाना चाहिए! No! You’re an IRC bouncer: you should not go to sleep!"])

At any rate, here are, unasked for, etymological notes on the four IRCv3 things with Korean or Japanese names, largely sourced from Wiktionary, as indicated, with some connecting text:

Goguma

[mainly sourced from: https://en.wiktionary.org/wiki/%EA%B3%A0%EA%B5%AC%EB%A7%88]

Named apparently after Korean 고구마 goguma “sweet potato” (cp. the web client by the same team, gamja “potato”). First attested in the Mulmyeonggo (물명고 / 物名考), 1824, as Early Modern Korean 고금아 (Yale: kokuma), borrowed from Japanese 孝行芋 (kōkō imo), a term used in the Tsushima dialect. Some earlier attestations are known, but they are in the context of quoting the dialectal Japanese word, not in a Korean context.

There’s also apparently a recent “Internet slang” sense: “a plot development which frustrates the reader (e.g. the protagonist fails to achieve their goal)” [from c. 2012].

The Japanese word 孝行芋 (kōkō imo) from which Korean 고구마 goguma is borrowed is apparently 孝行 (kōkō) [? “dutiful”??] + 芋 (imo) from Old Japanese, attested in the Nihon Shoki of 720, referring to “edible tubers”. May be a shift from older form うも (umo), ultimately from Proto-Japonic *umo. Cognate with Okinawan 芋 (‘nmu). [see: https://en.wiktionary.org/wiki/%E5%AD%9D%E8%A1%8C%E8%8A%8B#Japanese https://en.wiktionary.org/wiki/%E8%8A%8B#Japanese ]

The Japanese word 芋 (imo) is connected to Chinese 芋 [Old *ɢʷas, Modern Mandarin yù ] “taro”.

Seemingly a phono-semantic compound (形聲 / 形声, OC *ɢʷa, *ɢʷas): semantic 艸 (“grass; plant”) + phonetic 于 (OC *ɢʷa) – “taro”.

Compare Proto-Hmong-Mien *wouH (“taro”), Burmese ဝ (wa., “elephant foot yam”), Tibetan གྲོ་མ (gro ma, “ Argentina anserina (syn. Potentilla anserina), a plant with small edible tubers”).

There are various theories on how all these words are related:

• Schuessler (2007) considers it to be an areal word, comparing it to the Hmong-Mien and Burmese words. Schuessler (2015) does not consider the Tibetan word to be cognate.

• Blench (2012) suggests that the Chinese word is borrowed from Proto-Hmong-Mien and that the Burmese word may be a late loan from Old Chinese.

• STEDT reconstructs Proto-Sino-Tibetan *g/s-rwa (“taro; yam; tuber”), whence the Tibetan word. This etymon is regarded as allofamically related this word and 薯 (OC *djas).

• Gong Hwang-cherng (2002) and Baxter and Sagart (2017) also suggest that this word is related to the Tibetan word.

  [on the Chinese, see: https://en.wiktionary.org/wiki/%E8%8A%8B]

Gamja

[sourced from: https://en.wiktionary.org/wiki/%EA%B0%90%EC%9E%90]

Seemingly named from Korean 감자 gamja “potato”, which is a nativisation of the Sino-Korean term 감저 (甘藷, gamjeo, “lesser yam (Dioscorea esculenta)”). First attested 1766 in Korea, then referring to the sweet potato (Ipomoea batatas). The word came to refer to both “potato” and “sweet potato” in the nineteenth century, and later lost its original meaning. (So gamja meant “sweet potato” first; but partially supplanted by goguma.)

With 甘藷, gamjeo apparently borrowed from Early Modern Korean 감져 (kamcye), itself from 甘藷 [https://en.wiktionary.org/wiki/%E7%94%98%E8%97%B7].

[There’s also homophonous verbal form: 감자 (gamja) (plain hortative of 감다)

1. let’s close (our eyes)

2. let’s wash

   which is presumably unrelated.]

Soju

[source: https://en.wikipedia.org/wiki/Soju]

Seemingly named for Korean Soju (소주; 燒酒), which means “burned liquor”: with the first syllable, so (소; 燒; “burn”), referring to the heat of distillation and the second syllable, ju (주; 酒), meaning “alcoholic drink”. Etymological dictionaries record that China’s shaozhou (shāojiǔ, 烧酒), Japan’s shochu (shōchū, 焼酎), and Korea’s soju (soju, 燒酒) have the same etymology. [A Wikipedian has here added a note about unreliable sources(?).]

Another name for soju is noju (노주; 露酒; “dew liquor”), with its first syllable, no/ro (노/로; 露; “dew”), likening the droplets of the collected alcohol during the distilling process to dewdrops.

The origin of soju dates back to 13th-century Goryeo. The Yuan Mongols [the imperial dynasty of China founded by Kublai Khan, grandson of Genghis Khan] acquired the technique of distilling arak from the Persians during their invasions of the Levant, Anatolia, and Persia, and in turn introduced it to the Korean Peninsula during the Mongol invasions of Korea (1231–1259). Distilleries were set up around the city of Gaegyeong, the then-capital (current Kaesong). In the areas surrounding Kaesong, soju is still called arak-ju (아락주). Andong soju, the direct root of modern South Korean soju varieties, started as the home-brewed liquor developed in the city of Andong, where the Yuan Mongols’ logistics base was located during this era.

Senpai

[source: https://en.wiktionary.org/wiki/%E5%85%88%E8%BC%A9#Japanese]

Obviously named for Japanese 先輩 senpai “senior/superior in social standing or education or skill; an elder” (the homepage has a tagline “Your everyday IRC student” and also “Welcome home, desune~” and also a smiling anime-ish cat-ish logo).

The Japanese word was borrowed from the Middle Chinese 先輩 (sen pwojH). A doublet of ソンベ (sonbe) [With Japanese sonbe being itself borrowed from Korean 선배(先輩) (seonbae), which means “(chiefly in Korean media) sunbae (upperclassman or senior, in the context of Korea)"].

Both ultimately from Chinese 先輩 [ xiānbèi ] “older generation; senior; elder; ancestor; predecessor”.

The persist-text-scale Emacs package provides persist-text-scale-mode, which ensures that all adjustments made with text-scale-increase and text-scale-decrease are persisted and restored across sessions. As a result, the text size in each buffer remains consistent, even after restarting Emacs.

(By default, persist-text-scale-mode saves the text scale individually for each file-visiting buffer and applies a custom text scale for each special buffer. This behavior can be further customized by assigning a function to the persist-text-scale-buffer-category-function variable. The function determines how buffers are categorized by returning a category identifier based on the buffer’s context. Buffers within the same category will share the same text scale.)

Features

• Automatically persists and restores the text scale for all buffers.
• Periodically autosaves at intervals defined by persist-text-scale-autosave-interval (can be set to nil to disable or specified in seconds to enable).
• Supports unified text scaling across buffer categories.
• Offers fully customizable logic for categorizing buffers based on text scale.
• Lightweight and efficient, requiring minimal configuration.
• Enables custom buffer categorization by specifying a function for the persist-text-scale-buffer-category-function variable, ensuring that groups of buffers share the same persisted and restored text scale.

Installation: Emacs: Install with straight (Emacs version < 30)

To install persist-text-scale with straight.el:

1. It if hasn’t already been done, add the straight.el bootstrap code to your init file.
2. Add the following code to the Emacs init file:

(use-package persist-text-scale
  :ensure t
  :straight (persist-text-scale
             :type git
             :host github
             :repo "jamescherti/persist-text-scale.el")
  :custom
  (persist-text-scale-autosave-interval (* 7 60))
  :config
  (persist-text-scale-mode))

Alternative installation 1: Emacs: Installing with use-package and :vc (Built-in feature in Emacs version >= 30)

To install persist-text-scale with use-package and :vc (Emacs >= 30):

(use-package persist-text-scale
  :ensure t
  :vc (:url "https://github.com/jamescherti/persist-text-scale.el"
       :rev :newest)
  :custom
  (persist-text-scale-autosave-interval (* 7 60))
  :config
  (persist-text-scale-mode))

Alternative installation 2: Doom Emacs

Here is how to install persist-text-scale on Doom Emacs:

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

(package! persist-text-scale
 :recipe
 (:host github :repo "jamescherti/persist-text-scale.el"))

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

;; TODO: Load the mode here
(after! persist-text-scale
  (setq persist-text-scale-autosave-interval (* 7 60))
  (persist-text-scale-mode))

1. Run the doom sync command:

doom sync

Links

• persist-text-scale.el @GitHub

A well-known Emacs performance optimization advice is to boost the garbage collector threshold (so GC collections happen less frequently). That’s something I’ve had in my Emacs config for ages:

;; reduce the frequency of garbage collection by making it happen on
;; each 50MB of allocated data (the default is on every 0.76MB)
(setq gc-cons-threshold 50000000)

Probably I should increase it to 100MB+ these days, given the proliferation of more resource-hungry tooling (e.g. LSP). On the other hand there are also some counter arguments to consider when it comes to setting a high GC threshold:

The GC threshold setting after init is too high, IMNSHO, and its value seems arbitrary.

If the OP thinks that Emacs will GC as soon as it allocates 100 MiB, then that’s a grave mistake! What really happens is the first time Emacs considers doing GC, if at that time more than 100 MiB have been allocated for Lisp objects, Emacs will GC. And since neither Lisp programs nor the user have any control on how soon Emacs will decide to check whether GC is needed, the actual amount of memory by the time Emacs checks could be many times the value of the threshold.

My advice is to spend some time measuring the effect of increased GC threshold on operations that you care about and that take a long enough time to annoy, and use the lowest threshold value which produces a tangible improvement. Start with the default value, then enlarge it by a factor of 2 until you see only insignificant speedups. I would not expect the value you arrive at to be as high as 100 MiB.

– Eli Zaretskii, Emacs maintainer

One thing that’s not so common knowledge is that removing the GC limits during Emacs startup might improve the speedup quite a lot (the actual results will be highly dependent on your setup). Here’s what you need to do - just add the following bit to your early-init.el:

;; Temporarily increase GC threshold during startup
(setq gc-cons-threshold most-positive-fixnum)

;; Restore to normal value after startup (e.g. 50MB)
(add-hook 'emacs-startup-hook
          (lambda () (setq gc-cons-threshold (* 50 1024 1024))))

most-positive-fixnum is a neat constant that represents the biggest positive integer that Emacs can handle. There’s also most-negative-fixnum that you might find handy in some cases.

As for early-init.el - it was introduced in version 27 and is executed before init.el. Its primary purpose is to allow users to configure settings that need to take effect early in the startup process, such as disabling GUI elements or optimizing performance. This file is loaded before the package system and GUI initialization, giving it a unique role in customizing Emacs startup behavior.

Here are some other settings that people like to tweak in early-init.el:

;; Disable toolbars, menus, and other visual elements for faster startup:
(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

(setq inhibit-startup-screen t)

;; Load themes early to avoid flickering during startup (you need a built-in theme, though)
(load-theme 'modus-operandi t)

;; tweak native compilation settings
(setq native-comp-speed 2)

I hope you get the idea! If you have any other tips on speeding up the Emacs startup time, I’d love to hear them!

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

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

In this ~16-minute video, I demonstrate the new, in-development “query links” functionality of Denote. These are links that trigger a search when you interact with them. There are two types of query links: (i) search in file contents, or (ii) search in file names. When there are matches for a given query, those are displayed in a separate buffer, which uses the appropriate major mode. Query links complement the “direct links” Denote has always supported. Internally, they use the same infrastructure that Denote backlinks rely on (and we have had backlink support since the beginning).

Denote sources

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

In the last post I described how, for a particular project with certain naming conventions, I wanted to use emacs tree-sitter font-locking to highlight variables that might be used in the wrong context:

I found a way to make it work for simple expressions but it was relying on regular expression matching rather than tree-sitter parse trees. I set a goal of handling these types of expressions:

elevation_t[t]           // good
elevation_t[r]           // bug
elevation_t[t_from_r[r]] // good
elevation_t[r_from_t[t]] // bug
elevation_t[obj.t]       // good
elevation_t[obj.r]       // bug
elevation_t[t_from_r(r)] // good
elevation_t[r_from_t(t)] // bug
elevation_t[x.t_fn(x)]   // good
elevation_t[x.r_fn(x)]   // bug
elevation_t[x.t_arr[i]]  // good
elevation_t[x.r_arr[i]]  // bug
elevation_t[(t)]         // good
elevation_t[(r)]         // bug

What are my options for using tree-sitter to handle more cases? I decided to try the :pred feature of tree-sitter font lock. Using M-x treesit-explore-mode, I learned that the subscript expression looks like:

(subscript_expression 
   object: (_) 
   [
   index: (_)
   ]
)

That means I can match it with a rule that captures both the array and index as separate nodes:

(defun amitp-check-subscript (array index)
  (message "debug: %S %S" array index))

(defvar amitp/treesit-font-lock-typescript-indexing
  (treesit-font-lock-rules
   :language 'typescript
   :feature 'semantic-identifier
   :override t
   `(((subscript_expression
       object: (identifier) @array 
       index: (expression_statement) @index 
       (:pred amitp-check-subscript @array @index))))))

Those two arguments are treesit parse nodes. What can I do with them? The emacs manual has a page about how to navigate the parse tree and another page about querying the parse tree. In the docs found a function treesit-query-capture that can pattern match on a node and extract the parts.

I used that function to look for the identifier that most likely tells me what geometry type is being returned (r for region, s for side, t for triangle). Examples:

• in t_foo_r(r), the identifier t_foo_r tells me this is likely a t (triangle)
• in t_obj[i].r_elevation, the identifier r_elevation tells me this is likely an r (region)
• in map[i].s_inner_t(t_queue[0]), the identifier s_inner_t tells me this is likely an s (side)

I think this is where tree-sitter can do better than regular expression based matching. I wrote a function to find the key identifier:

(defun amitp/treesit-top-typescript-node (node)
  "Try to find the identifier that represents a node's return value"
  (let ((results
         (treesit-query-capture
          node
          '(((identifier) @identifier)
            ((member_expression property: (property_identifier) @property))
            ((subscript_expression object: (_) @expr))
            ((call_expression function: (_) @expr))
            ((parenthesized_expression (_) @expr))))))
    (if (assoc 'expr results)
        (amitp/treesit-top-typescript-node (cdr (assoc 'expr results)))
      ;; prefer the property if tree-sitter matches both
      (or (cdr (assoc 'property results)) (cdr (assoc 'identifier results))))))

I wrote a function detect a mismatch:

(defun amitp-check-subscript-mismatch (array index)
  ;; note: my usual naming convention is amitp/foo but tree-sitter won't accept that
  (let* ((array-name (buffer-substring (treesit-node-start array) (treesit-node-end array)))
         (top (amitp/treesit-top-typescript-node index))
         (index-name (buffer-substring (treesit-node-start top) (treesit-node-end top))))
    (and
     (or (= (length array-name) 1) (equal "_" (substring array-name -2 -1)))
     (or (= (length index-name) 1) (equal "_" (substring index-name 1 2)))
     (not (equal (substring array-name -1) (substring index-name 0 1))))))

Then I used the tree-sitter :pred feature to only highlight if there's a mismatch:

(defface array-error)
(defface index-error)

(defvar amitp/treesit-font-lock-typescript-indexing
  (treesit-font-lock-rules
   :language 'typescript
   :feature 'semantic-identifier
   :override t
   '(((subscript_expression
       object: (_) @array-error
       index: (_) @index-error
       (:pred amitp-check-subscript-mismatch @array-error @index-error))))))
     ;; todo: add call_expression

Does it work? Yes!

But there's something a little weird here. Why do r+1 and 1+r get flagged even though I never actually handle binary operators in my amitp/treesit-top-typescript-node function? Something to investigate later.

The next feature I wanted was to highlight only the "type" character instead of the entire identifier. I couldn't figure out how, so I asked on Reddit, where /u/eleven_cupfuls gave me a solution: the @face-name can be a @function-name instead. Thank you!

Instead of using :pred to tell font-lock whether to highlight something, I need to highlight it myself. I changed the treesit font lock rules to call my function instead of applying a face:

(defvar amitp/treesit-font-lock-typescript-indexing
  (treesit-font-lock-rules
   :language 'typescript
   :feature 'semantic-identifier
   :override t
   '(((subscript_expression) @amitp-highlight-subscript-mismatch)
     ((call_expression) @amitp-highlight-subscript-mismatch))))

My function now receives the entire expression instead of receiving the array and index parts separately like the :pred version. So I need to find a way to extract the right information. I can use treesit-query-capture like before, right?

It was at this point that I learned treesit-query-capture pattern matches against the entire tree and not only the top node. That explains why it was finding r+1 and 1+r. It was looking for any identifier anywhere in the subtree. Oops.

I rewrote amitp/treesit-top-typescript-node to use treesit-node-type instead of treesit-query-capture:

(defun amitp/treesit-top-typescript-node (node)
  "Try to find the identifier that represents a node's return value"
  (pcase (treesit-node-type node)
    ("identifier" node)
    ("member_expression" (treesit-node-child-by-field-name node "property"))
    ("subscript_expression" (amitp/treesit-top-typescript-node (treesit-node-child-by-field-name node "object")))
    ("call_expression" (amitp/treesit-top-typescript-node (treesit-node-child-by-field-name node "function")))
    ("parenthesized_expression" (amitp/treesit-top-typescript-node (treesit-node-child node 1)))
    (_ nil)))

It would've been cleaner if pcase could pattern match against these nodes, but it's not too bad.

And then I wrote a new amitp-highlight-subscript-mismatch function to analyze subscript nodes (and function calls too) to make sure the names match:

(defun amitp-highlight-subscript-mismatch (node override start end &rest _)
  "Highlight mismatching variable names in amitp's geometry mesh code"
  (let* ((parts (pcase (treesit-node-type node)
                  ("subscript_expression" (list (treesit-node-child-by-field-name node "object")
                                               (treesit-node-child-by-field-name node "index")))
                  ("call_expression" (list (treesit-node-child-by-field-name node "function")
                                           (treesit-node-child
                                            (treesit-node-child-by-field-name node "arguments")
                                            1))))))
    (when parts
      (let* ((array (nth 0 parts))
             (index (nth 1 parts))
             (array-name (treesit-node-text array))
             (top (amitp/treesit-top-typescript-node index))
             (index-name (or (treesit-node-text array) ""))
             (face (if (and ;; todo also check (>= (length index-name) 1)
                        (or (= (length array-name) 1) (equal "_" (substring array-name -2 -1)))
                        (or (= (length index-name) 1) (s-match "[_0-9]" (substring index-name 1 2))))
                       (if (equal (substring array-name -1) (substring index-name 0 1))
                           'index-good
                         'index-bad)
                     nil)))
        (when face
          (treesit-fontify-with-override (- (treesit-node-end array) 2) (treesit-node-end array) face override)
          (treesit-fontify-with-override (treesit-node-start top) (min (treesit-node-end top) (+ 2 (treesit-node-start top))) face override))))))

It's a little bit long but it seems to work:

However, there are things I haven't figured out, like why certain expressions don't trigger the (subscript_expression) font lock rule:

r => mesh.foo_r[r]);     // matches
(r => mesh.foo_r[r]);    // matches
foo(mesh.foo_r[r]);      // matches
foo(r => mesh.foo_r[r]); // doesn't match

That's a problem for another day. I also want to:

1. apply these rules only to files in which I use that naming convention
2. tighten the matching to apply only to the letters r, s, t
3. remove the green "it's ok" color and only leave the red "warning" color

This was a fun adventure. I'm not sure this is the best approach but it was a nice excuse to play with emacs tree-sitter.

One of the things I like about blogging from Org Mode in Emacs is that it's easy to add properties to the section that I'm working on and then use those property values elsewhere. For example, I've modified Emacs to simplify tooting a link to my blog post and saving the Mastodon status URL in the EXPORT_MASTODON property. Then I can use that in my 11ty static site generation process to include a link to the Mastodon thread as a comment option.

First, I need to export the property and include it in the front matter. I use .11tydata.json files to store the details for each blog post. I modified ox-11ty.el so that I could specify functions to change the front matter (org-11ty-front-matter-functions, org-11ty--front-matter):

(defvar org-11ty-front-matter-functions nil
  "Functions to call with the current front matter plist and info.")
(defun org-11ty--front-matter (info)
  "Return front matter for INFO."
  (let* ((date (plist-get info :date))
         (title (plist-get info :title))
         (modified (plist-get info :modified))
         (permalink (plist-get info :permalink))
         (categories (plist-get info :categories))
         (collections (plist-get info :collections))
         (extra (if (plist-get info :extra) (json-parse-string
                                             (plist-get info :extra)
                                             :object-type 'plist))))
    (seq-reduce
     (lambda (prev val)
       (funcall val prev info))
     org-11ty-front-matter-functions
     (append
      extra
      (list :permalink permalink
            :date (if (listp date) (car date) date)
            :modified (if (listp modified) (car modified) modified)
            :title (if (listp title) (car title) title)
            :categories (if (stringp categories) (split-string categories) categories)
            :tags (if (stringp collections) (split-string collections) collections))))))

Then I added the EXPORT_MASTODON Org property as part of the front matter. This took a little figuring out because I needed to pass it as one of org-export-backend-options, where the parameter is defined as MASTODON but the actual property needs to be called EXPORT_MASTODON.

(defun my-org-11ty-add-mastodon-to-front-matter (front-matter info)
  (plist-put front-matter :mastodon (plist-get info :mastodon)))
(with-eval-after-load 'ox-11ty
  (cl-pushnew
   '(:mastodon "MASTODON" nil nil)
   (org-export-backend-options (org-export-get-backend '11ty)))
  (add-hook 'org-11ty-front-matter-functions #'my-org-11ty-add-mastodon-to-front-matter))

Then I added the Mastodon field as an option to my comments.cjs shortcode. This was a little tricky because I'm not sure I'm passing the data correctly to the shortcode (sometimes it ends up as item.data, sometimes it's item.data.data, …?), but with ?., I can just throw all the possibilities in there and it'll eventually find the right one.

const pluginRss = require('@11ty/eleventy-plugin-rss');
module.exports = function(eleventyConfig) {
  function getCommentChoices(data, ref) {
    const mastodonUrl = data.mastodon || data.page?.mastodon || data.data?.mastodon;
    const mastodon = mastodonUrl && `<a href="${mastodonUrl}" target="_blank" rel="noopener noreferrer">comment on Mastodon</a>`;
    const url = ref.absoluteUrl(data.url || data.permalink || data.data?.url || data.data?.permalink, data.metadata?.url || data.data?.metadata?.url);
    const subject = encodeURIComponent('Comment on ' + url);
    const body = encodeURIComponent("Name you want to be credited by (if any): \nMessage: \nCan I share your comment so other people can learn from it? Yes/No\n");
    const email = `<a href="mailto:sacha@sachachua.com?subject=${subject}&body=${body}">e-mail me at sacha@sachachua.com</a>`;
    const disqusLink = url + '#comment';
    const disqusForm = data.metadata?.disqusShortname && `<div id="disqus_thread"></div>
<script>
 var disqus_config = function () {
   this.page.url = "${url}";
   this.page.identifier = "${data.id || ''} ${data.metadata?.url || ''}?p=${ data.id || data.permalink || this.page?.url}";
   this.page.disqusTitle = "${ data.title }"
   this.page.postId = "${ data.id || data.permalink || this.page?.url }"
 };
 (function() { // DON'T EDIT BELOW THIS LINE
   var d = document, s = d.createElement('script');
   s.src = 'https://${ data.metadata?.disqusShortname }.disqus.com/embed.js';
   s.setAttribute('data-timestamp', +new Date());
   (d.head || d.body).appendChild(s);
 })();
</script>
<noscript>Disqus requires Javascript, but you can still e-mail me if you want!</noscript>`;
    return { mastodon, disqusLink, disqusForm, email };
  }
  eleventyConfig.addShortcode('comments', function(data, linksOnly=false) {
    const { mastodon, disqusForm, disqusLink, email } = getCommentChoices(data, this);
    if (linksOnly) {
      return `You can ${mastodon ? mastodon + ', ' : ''}<a href="${disqusLink}">comment with Disqus (JS required)</a>${mastodon ? ',' : ''} or ${email}.`;
    } else {
      return `<div id="comment"></div>
You can ${mastodon ? mastodon + ', ' : ''}comment with Disqus (JS required)${mastodon ? ', ' : ''} or you can ${email}.
${disqusForm || ''}`;}
  });
}

I included it in my post.cjs shortcode:

module.exports = eleventyConfig =>
eleventyConfig.addShortcode('post', async function(item, index, includeComments) {
  let comments = '<div class="comments">' + (includeComments ? this.comments(item) : this.comments(item, true)) + '</div>';
  let categoryList = item.categories || item.data && item.data.categories;
  let categoriesFooter = '', categories = '';
  if (categoryList && categoryList.length > 0) {
    categoriesFooter = `<div class="footer-categories">More posts about ${this.categoryList(categoryList)}</div>`;
    categories = `| <span class="categories">${this.categoryList(categoryList)}</span>`;
  }

  return  `<article class="post" id="index${index}" data-url="${item.url || item.permalink || ''}">
<header><h2 data-pagefind-meta="title"><a href="${item.url || item.permalink || ''}">${item.title || item.data && item.data.title}</a></h2>
${this.timeInfo(item)}${categories}
</header>
<div class="entry">
${await (item.templateContent || item.layoutContent || item.data?.content || item.content || item.inputContent)}
</div>
${comments}
${categoriesFooter}
</article>`;
});

I also included it in my RSS item template to make it easier for people to send me comments without having to dig through my website for contact info.

const posthtml = require("posthtml");
const urls = require("posthtml-urls");

module.exports = (eleventyConfig) => {
  eleventyConfig.addAsyncShortcode('rssItem', async function(item) {
    let content = item.templateContent.replace(/--/g, '--');
    if (this.transformWithHtmlBase) {
      content = await this.transformWithHtmlBase(content);
    }
    return `<item>
    <title>${item.data.title}</title>
    <link>${this.absoluteUrl(item.url, item.data.metadata.url)}</link>
    <dc:creator><![CDATA[${item.data.metadata.author.name}]]></dc:creator>
    <pubDate>${item.date.toUTCString()}</pubDate>
    ${item.data.categories?.map((cat) => `<category>${cat}</category>`).join("\n") || ''}
    <guid isPermaLink="false">${this.guid(item)}</guid>
    <description><![CDATA[${content}
<p>${this.comments(item, true)}</p>]]></description>
    </item>`;
  });
};

The new workflow I'm trying out seems to be working:

1. Keep npx eleventy --serve running in the background, using .eleventyignore to make rebuilds reasonably fast.
2. Export the subtree with C-c e s 1 1, which uses org-export-dispatch to call my-org-11ty-export with the subtree.
3. After about 10 seconds, use my-org-11ty-copy-just-this-post and verify.
4. Use my-mastodon-11ty-toot-post to compose a toot. Edit the toot and post it.
5. Check that the EXPORT_MASTODON property has been set.
6. Export the subtree again, this time with the front matter.
7. Publish my whole blog.

Next, I'm thinking of modifying my-mastodon-11ty-toot-post so that it includes a list of links to blog posts I might be building on or responding to, and possibly the handles of people related to those blog posts or topics. Hmm…

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

Over at The MKat, Marie K. Ekeberg has a post that brings me back to my earliest days of using Emacs. Before I was assimilated, I tried several times to warm up to Emacs but it wouldn’t take. Ekeberg’s post reminds me why. It was what I considered the schizophrenic default scrolling. You would move the cursor down the screen and suddenly, about three quarters of the way down, the screen would jump several lines. Every time I saw that, I would abandon my attempt to embrace Emacs and run screaming back to Vim.

In her post on smoother scrolling, Ekeberg offers an explanation for this bizarre behavior that I’m pretty sure is correct. The TL;DR is that in the old days, when Emacs was developed, scrolling was an expensive operation so rather than scroll by line, Emacs would scroll by (essentially) half pages.

I have no idea why the default hasn’t long since been changed but as far as I know, it hasn’t. I say, “as far as I know” because years and years ago I did what Ekeberg suggests and implemented smooth scrolling. I haven’t looked back.

It turns out that fixing this is far from trivial. I have no memory of how I figured it out but I do know that it involved pleading with the Internet for an answer. Take a look at Ekeberg’s post to see the answer. What she suggests is essentially what I did. As I said, not at all obvious.

It’s odd how a simple thing like scrolling can ruin your appreciation of Emacs but it sure did affect mine. Don’t let that happen to you. Take a look at Ekeberg’s post and find peace of mind.

Last Friday, I was genuinely surprised by a live demo of my Emacs Solo configuration on the System Crafters Weekly Show. Watching the live demo was an eye-opener, as I hadn't expected the project to get such attention, especially in a live setting. Seeing David Wilson take a deep dive into the setup, testing the configuration live, and exploring how powerful Emacs can be with only its built-in packages was both humbling and inspiring.

For more details and to explore the configuration yourself, visit the Emacs Solo GitHub repository.

The Emacs Solo configuration is all about returning to the roots of Emacs. It's a minimalist setup designed to challenge myself and test the full potential of Emacs using only its built-in functionality. The goal was to create an efficient, yet fully functional environment, all while keeping things as light and fast as possible. No external dependencies, no clutter. Just pure, unadulterated Emacs.

The Project: Emacs Solo

Emacs Solo is a configuration that embraces the power of Emacs without relying on external packages. It's a setup I go back to from time to time to remind myself of how much can be accomplished with just what Emacs offers out of the box.

This configuration is designed to be both powerful and lightweight, allowing for a fast, efficient workflow with a focus on simplicity and minimalism. The project includes several useful features for day-to-day tasks like searching, editing, and navigating—everything you need for an efficient Emacs experience.

Some of the highlights of the project include:

» A preview of icomplete-verical enhancements I proposed to the Emacs core team (custom prefixes, vertico style setup, and inline completion closer to corfu/company that works on text buffers and eshell).

» An experimental custom git-gutter-like feature.

» Supercharged eshell customization.

» Custom solutions for editing multiple search entries.

» Built-in news readers like Gnus and Newsticker.

» Advanced file diffing and version control.

» Extended viper mode for those who prefer vim-style editing.

» Tree-sitter modes.

» LSP configurations.

» Custom rainbown-mode like.

» And many customizations of built-in packages.

The idea is that Emacs is already a powerful IDE, and with a bit of clever customization, it can be made into something even more streamlined, adaptable, and effective without the need for external packages.

Watch the Demo

Here's the video of the live demo from the System Crafters Weekly Show:

» Also available here

Conclusion

I’d like to take this opportunity to thank David Wilson for the amazing show and to the System Crafters community for their continued support and enthusiasm around Emacs. I also want to express my gratitude to everyone who has contributed code that I’ve borrowed and learned from over the years. Particularly Gopar and Protesilaos. Without the shared knowledge and experience from these fantastic people, the Emacs Solo project wouldn't have been possible.

As always, the beauty of Emacs lies in its community, and I'm grateful for all the inspiration, contributions, and shared wisdom that make projects like Emacs Solo come to life. Thank you to everyone who continues to inspire and teach me along the way.

Sometimes I want to copy a toot and include it in my Org Mode notes, like when I post a thought and then want to flesh it out into a blog post. This code defines my-mastodon-org-copy-toot-content, which converts the toot text to Org Mode format using Pandoc and puts it in the kill ring so I can yank it somewhere else.

(defun my-mastodon-toot-at-url (&optional url)
  "Return JSON toot object at URL.
If URL is nil, return JSON toot object at point."
  (if url
      (let* ((search (format "%s/api/v2/search" mastodon-instance-url))
             (params `(("q" . ,url)
                       ("resolve" . "t"))) ; webfinger
             (response (mastodon-http--get-json search params :silent)))
        (car (alist-get 'statuses response)))
    (mastodon-toot--base-toot-or-item-json)))

(defun my-mastodon-org-copy-toot-content (&optional url)
  "Copy the current toot's content as Org Mode.
Use pandoc to convert.

When called with \\[universal-argument], prompt for a URL."
  (interactive (list
                (when current-prefix-arg
                  (read-string "URL: "))))

  (let ((toot (my-mastodon-toot-at-url url)))
    (with-temp-buffer
      (insert (alist-get 'content toot))
      (call-process-region nil nil "pandoc" t t nil "-f" "html" "-t" "org")
      (kill-new
       (concat
        (org-link-make-string
         (alist-get 'url toot)
         (concat "@" (alist-get 'acct (alist-get 'account toot))))
        ":\n\n#+begin_quote\n"
        (string-trim (buffer-string)) "\n#+end_quote\n"))
      (message "Copied."))))

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

Back in the bad old days when personal computers weren’t nearly as reliable as they are today, it was common to have your computer crash when you were right in the middle of writing a document. Because of that, a common mantra was, “save early and often”. That way, when the crash came you would have only a few lines to rewrite.

I first heard the particular expression “save early and often” from Jerry Pournelle but it may not have originated with him. It was common advice back then but the humorous twist does seem like Pournelle, so who knows. In any event, in those days it wasn’t just good advice, it was mandatory.

I was reminded of all this the other day when I was writing yesterday’s post on the latency of computer operations. I was switching back and forth between the post’s Emacs buffer and Ahmad’s post in Safari, when Safari suddenly froze and I couldn’t find a way to break out of it and get back to Emacs to save my buffer, which, sadly, I hadn’t bothered to backup as I went along. In the end, I had to reboot the machine to get things back to normal.

Of course my whole post was gone when my laptop came back up. Note that this was not Emacs’ fault. It was Safari that froze and it was me that didn’t bother saving my work. Actually, Emacs was the hero in all this because the autosave function rescued me from my folly. I hardly ever need to use it so I always have a hard time remembering what to do but in the end I got almost my whole post back.

The takeaway from all this is that even with reliable hardware and software, crashes and freezes can still happen so if you care about your work make sure to back it up often. Or, as Pournelle would have it, early and often. If you don’t, the day will come when even Emacs can’t save you.

I sometimes want to thank a bunch of people for contributing to a Mastodon conversation. The following code lets me collect handles in a single kill ring entry by calling it with my point over a handle or a toot, or with an active region.

(defvar my-mastodon-handle "@sacha@social.sachachua.com")
(defun my-mastodon-copy-handle (&optional start-new beg end)
  "Append Mastodon handles to the kill ring.

Use the handle at point or the author of the toot.  If called with a
region, collect all handles in the region.

Append to the current kill if it starts with @. If not, start a new
kill. Call with \\[universal-argument] to always start a new list.

Omit my own handle, as specified in `my-mastodon-handle'."
  (interactive (list current-prefix-arg
                     (when (region-active-p) (region-beginning))
                     (when (region-active-p) (region-end))))
  (let ((handle
         (if (and beg end)
             ;; collect handles in region
             (save-excursion
               (goto-char beg)
               (let (list)
                 ;; Collect all handles from the specified region
                 (while (< (point) end)
                   (let ((mastodon-handle (get-text-property (point) 'mastodon-handle))
                         (button (get-text-property (point) 'button)))
                     (cond
                      (mastodon-handle
                       (when (and (string-match "@" mastodon-handle)
                                  (or (null my-mastodon-handle)
                                      (not (string= my-mastodon-handle mastodon-handle))))
                         (cl-pushnew
                          (concat (if (string-match "^@" mastodon-handle) ""
                                    "@")
                                  mastodon-handle)
                          list
                          :test #'string=))
                       (goto-char (next-single-property-change (point) 'mastodon-handle nil end)))
                      ((and button (looking-at "@"))
                       (let ((text-start (point))
                             (text-end (or (next-single-property-change (point) 'button nil end) end)))
                         (dolist (h (split-string (buffer-substring-no-properties text-start text-end) ", \n\t"))
                           (unless (and my-mastodon-handle (string= my-mastodon-handle h))
                             (cl-pushnew h list :test #'string=)))
                         (goto-char text-end)))
                      (t
                       ;; collect authors of toots too
                       (when-let*
                           ((toot (mastodon-toot--base-toot-or-item-json))
                            (author (and toot
                                         (concat "@"
                                                 (alist-get
                                                  'acct
                                                  (alist-get 'account (mastodon-toot--base-toot-or-item-json)))))))
                         (unless (and my-mastodon-handle (string= my-mastodon-handle author))
                           (cl-pushnew
                            author
                            list
                            :test #'string=)))
                       (goto-char (next-property-change (point) nil end))))))
                 (setq handle (string-join (seq-uniq list #'string=) " "))))
           (concat "@"
                   (or
                    (get-text-property (point) 'mastodon-handle)
                    (alist-get
                     'acct
                     (alist-get 'account (mastodon-toot--base-toot-or-item-json))))))))
    (if (or start-new (null kill-ring) (not (string-match "^@" (car kill-ring))))
        (kill-new handle)
      (dolist (h (split-string handle " "))
        (unless (member h (split-string " " (car kill-ring)))
          (setf (car kill-ring) (concat (car kill-ring) " " h)))))
    (message "%s" (car kill-ring))))

Another perk of tooting from Emacs using mastodon.el. =)

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

I was feeling envious of the Obsidian Web Clipper, which is quite fancy, so I thought I’d try leveraging it for use with Denote.

My first run at this involves a couple of steps:

• Tweak the web clipper to save files using Denote’s format and front matter
• Save the file without adding it to an Obsidian vault
• Move the saved file into my Denote folder

Here’s the Web Clipper template configuration I ended up with:

It was important to set the “Tags” property type to “Text” rather than the default “Multitext” so that Denote does the right thing with it when renaming the file later.

In the Web Clipper’s advanced settings, I set the behavior to “Save file…” rather than “Add to Obsidian”.

OK, so now after using the Web Clipper, I get a Markdown file¹with a (mostly) Denote-compatible file name and front matter in my ~/Downloads folder. Here’s what clipping this post looks like:

To get the file into my denote-directory, I use a rule in Hazel. Hazel watches my Downloads folder for any new file whose name contains the string “__clipping”, and automatically moves it into a “clippings” folder in my Denote folder.

The only manual step remaining is to finish renaming the files using Denote. I don’t yet know how to have the Web Clipper “slugify” the file name, so I have Denote do it. This can be done in batch using Dired, so it’s not a huge burden.

If there’s a simpler way to get a nicely-formatted Org mode file from a web page directly to my Denote folder, I’m all ears, but for now…

Take that, Obsidian! 😄

This week in ollama-buddy updates, I have mostly been experimenting with ChatGPT integration! Yes, it is not a local LLM, so not ollama, hence entirely subverting the whole notion and fundamental principles of this package! This I know, and I don’t care; I’m having fun. I use ChatGPT and would rather use it in Emacs through the now-familiar ollama-buddy framework, so why not? I’m also working on Claude integration too.

My original principles of a no-config Emacs ollama integration still hold true, as by default, you will only see ollama models available. But with a little tweak to the configuration, with a require here and an API key there, you can now enable communication with an online AI. At the moment, I use Claude and ChatGPT, but if I can get Claude working, I might think about just adding in a basic template framework to easily slot in others. At the moment, there is a little too much internal ollama-buddy faffing to incorporate these external AIs into the main package, but I’m sure I can figure out a way to accommodate separate elisp external AIs.

In other ollama-buddy news, I have now added support for the stream variable in the ollama API. By default, I had streaming on, and I guess why wouldn’t you? It is a chat, and you would want to see “typing” or tokens arriving as they come in?. But to support more of the API, you can toggle it on and off, so if you want, you can sit there and wait for the response to arrive in one go and maybe it can be less distracting (and possibly more efficient?).

Just a note back on the topic of online AI offerings: to simplify those integrations, I just disabled streaming for the response to arrive in one shot. Mainly, I just couldn’t figure out the ChatGPT streaming, and for an external offering, I wasn’t quite willing to spend more time on it, and due to the speed of these online behemoths, do you really need to see each token come in as it arrives?

Oh, there is something else too, something I have been itching to do for a while now, and that is to write a Texinfo document so a manual can be viewed in Emacs. Of course, this being an AI-based package, I fed in my ollama-buddy files and got Claude to generate one for me (I have a baby and haven’t the time!). Reading through it, I think it turned out pretty well :) It hasn’t been made automatically available on MELPA yet, as I need to tweak the recipe, but you can install it for yourself.

Anyways, see below for the changelog gubbins:

<2025-03-24 Mon> 0.9.11

Added the ability to toggle streaming on and off

• Added customization option to enable/disable streaming mode
• Implemented toggle function with keybindings (C-c x) and transient menu option
• Added streaming status indicator in the modeline

The latest update introduces the ability to toggle between two response modes:

• Streaming mode (default): Responses appear token by token in real-time, giving you immediate feedback as the AI generates content.
• Non-streaming mode: Responses only appear after they’re fully generated, showing a “Loading response…” placeholder in the meantime.

While watching AI responses stream in real-time is often helpful, there are situations where you might prefer to see the complete response at once:

• When working on large displays where the cursor jumping around during streaming is distracting
• When you want to focus on your work without the distraction of incoming tokens until the full response is ready

The streaming toggle can be accessed in several ways:

1. Use the keyboard shortcut C-c x
2. Press x in the transient menu
3. Set the default behaviour through customization:

         (setq ollama-buddy-streaming-enabled nil) ;; Disable streaming by default
   

The current streaming status is visible in the modeline indicator, where an “X” appears when streaming is disabled.

<2025-03-22 Sat> 0.9.10

Added experimental OpenAI support!

Yes, that’s right, I said I never would do it, and of course, this package is still very much ollama-centric, but I thought I would just sneak in some rudimentary ChatGPT support, just for fun!

It is a very simple implementation, I haven’t managed to get streaming working, so Emacs will just show “Loading Response…” as it waits for the response to arrive. It is asynchronous, however, so you can go off on your Emacs day while it loads (although being ChatGPT, you would think the response would be quite fast!)

By default, OpenAI/ChatGPT will not be enabled, so anyone wanting to use just a local LLM through ollama can continue as before. However, you can now sneak in some experimental ChatGPT support by adding the following to your Emacs config as part of the ollama-buddy set up.

(require 'ollama-buddy-openai nil t)
(setq ollama-buddy-openai-api-key "<big long key>")

and you can set the default model to ChatGPT too!

(setq ollama-buddy-default-model "GPT gpt-4o")

With this enabled, chat will present a list of ChatGPT models to choose from. The custom menu should also now work with chat, so from anywhere in Emacs, you can push predefined prompts to the ollama buddy chat buffer now supporting ChatGPT.

There is more integration required to fully incorporate ChatGPT into the ollama buddy system, like token rates and history, etc. But not bad for a first effort, methinks!

Here is my current config, now mixing ChatGPT with ollama models:

(use-package ollama-buddy
  :bind
  ("C-c o" . ollama-buddy-menu)
  ("C-c O" . ollama-buddy-transient-menu-wrapper)
  :custom
  (ollama-buddy-openai-api-key "<very long key>")
  (ollama-buddy-default-model "GPT gpt-4o")
  :config
  (require 'ollama-buddy-openai nil t)
  (ollama-buddy-update-menu-entry
   'refactor-code :model "qwen2.5-coder:7b")
  (ollama-buddy-update-menu-entry
   'git-commit :model "qwen2.5-coder:3b")
  (ollama-buddy-update-menu-entry
   'describe-code :model "qwen2.5-coder:3b")
  (ollama-buddy-update-menu-entry
   'dictionary-lookup :model "llama3.2:3b")
  (ollama-buddy-update-menu-entry
   'synonym :model "llama3.2:3b")
  (ollama-buddy-update-menu-entry
   'proofread :model "GPT gpt-4o")
  (ollama-buddy-update-menu-entry
   'custom-prompt :model "deepseek-r1:7b"))

<2025-03-22 Sat> 0.9.9

Added texinfo documentation for future automatic installation through MELPA and created an Emacs manual.

If you want to see what the manual would look like, just download the docs directory from github, cd into it, and run:

make
sudo make install-docs

Then calling up info C-h i and ollama buddy will be present in the Emacs menu, or just select m and search for Ollama Buddy

For those interested in the manual, I have converted it into html format, which is accessible here:

/tags/ollama-buddy/

It has been converted using the following command:

makeinfo --html --no-split ollama-buddy.texi -o ollama-buddy.html
pandoc -f html -t org -o ollama-buddy.org ollama-buddy.html

<2025-03-20 Thu> 0.9.9

Intro message with model management options (select, pull, delete) and option for recommended models to pull

• Enhance model management and selection features
• Display models available for download but not yet pulled

Read Jeremy's post on quickly switching the default browser.

I had a shell script to do this as well. Doing it from Emacs makes more sense because I can have a completion UI.

So, here's my modified version for Linux:

(defun sj/default-browser (&optional name)
  "Set the default browser based on the given NAME."
  (interactive
   (list
    (completing-read
     "Browser: "
     (split-string
      (shell-command-to-string
       "find /usr/share/applications ~/.local/share/applications -name \"*.desktop\" -exec grep -l \"Categories=.*WebBrowser\" {} \\;")
      "\n" t))))
  (let ((browser-desktop (file-name-nondirectory name)))
    (shell-command (format "xdg-mime default %s text/html" browser-desktop))
    (shell-command (format "xdg-mime default %s application/xhtml+xml" browser-desktop))
    (shell-command (format "xdg-mime default %s application/x-extension-html" browser-desktop))
    (shell-command (format "xdg-settings set default-web-browser %s" browser-desktop))))

As a plus, it automatically lists the installed browsers based on .desktop files on your system.

It’s Monday. Most of us are looking around bleary eyed wondering what happened to the weekend that just started. Here’s a little humor to get you warmed up for what’s to come. Over at the Emacs subreddit, bruchieOP posts the Ten Commandments of the Church of Emacs.

It’s a satirical look at the beliefs that most of us Emacs users hold near and dear. Note that satirical qualifier. For example, lots of people use and swear by “pre-configured distributions”, such as Doom and Spacemacs, as even bruchieOP acknowledges. Still, most of you will identify and agree the majority of the prescriptions.

Take a couple of minutes to enjoy the post and then back to work. Emacs is waiting.

• Upcoming events (iCal file, Org):
  • Emacs Berlin (hybrid, in English) https://emacs-berlin.org/ Wed Mar 26 1030 America/Vancouver - 1230 America/Chicago - 1330 America/Toronto - 1730 Etc/GMT - 1830 Europe/Berlin - 2300 Asia/Kolkata – Thu Mar 27 0130 Asia/Singapore
  • Emacs Paris: S: Emacs workshop in Paris (online) https://emacs-doctor.com/ Tue Apr 1 0830 America/Vancouver - 1030 America/Chicago - 1130 America/Toronto - 1530 Etc/GMT - 1730 Europe/Berlin - 2100 Asia/Kolkata - 2330 Asia/Singapore
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/306712497/ Wed Apr 2 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Thu Apr 3 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Apr 4 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
• Emacs configuration:
  • initial major mode #emacs #coding #programming (00:29)
  • My latest whitespaces / long lines config
  • gchape/emacs.d - Optimized Emacs Config for Web Development (Reddit)
  • Looking for users to test a new version of key-chord
• Emacs Lisp:
  • Listful Andrew: Hash tables look better in Emacs 30
  • Xah Talk Show 2025-03-21 Ep631 emacs lisp coding html insert doctype (05:50)
• Navigation:
  • You have no idea how powerful isearch is! (Reddit, Irreal)
  • Irreal: Movement Commands
  • Emacs Redux: Relative Line Numbers (Irreal)
  • Speeding up projectile on Windows (@naiquevin@fosstodon.org)
  • Quickly change multiple instances with iedit #emacs #coding #programming (01:31)
  • Jump to specific places in Emacs #coding #programming (00:58)
• Dired:
  • Highlight changes in wdired mode in Emacs #emacs #coding #programming (00:28)
• Org Mode:
  • TAONAW - Emacs and Org Mode: back in the groove
  • Irreal: Emacs for creative non-techies who want to get off Google Docs
  • org-capture de emacs en español 🇪🇦 (23:05)
  • Listful Andrew: Splurge — Track your expenses with a simple Org table (Emacs package)
  • Comment ajouter une tâche à votre agenda org ? #orgmode #agenda #emacs #gnu #productivity #organized (00:59)
  • Sacha Chua: Org Mode: Merge top-level items in an item list
  • org-mode TABLE spreadsheet plot (無音) (06:15)
  • indexed: Distilled the performant parts of org-node into a library (Reddit)
  • Import, export, and integration:
    • Doom + Org: use clipboard for titled link or webpage content as subtree
    • Sharing Org Roam content
    • How I Wrote This Website (@trevdev@fosstodon.org)
    • Grant Rettke: I Need Your Help Adding org-utf-to-xetex to MELPA
    • ~taingram/org-publish-rss - Automatically generate RSS feeds for org-publish projects - sourcehut git (@tiang@mastodon.social)
    • Simple agenda, not in Emacs only (about "pal" program)
    • John Rakestraw | Using the HTML details disclosure element (@johnrakestraw@mastodon.online)
• Denote:
  • Protesilaos Stavrou: Emacs: first look at query links for Denote version 4.0.0
• Completion:
  • Irreal: Emacs Completion As A Game Changer
• Coding:
  • Emacs Solo: A Minimal IDE Configuration - System Crafters Live! (01:38:59)
  • Agile & Coding: Are we there yet? (@davidvujic@mastodon.nu) Continuing with the work on tooling support for interactive & fun development with Python
  • Rubyで簡単な言語サーバーを書いてみた #Emacs - Qiita (@sonota88@fedibird.com)
  • ~csantosb/emacs.vhdl-ide - GNU/Emacs as a full VHDL IDE - sourcehut git (@csantosb@sigmoid.social)
  • jadestrong/lsp-proxy: An LSP client for Emacs implemented in Rust. (@cjk@chaos.social)
  • How to run a C program in Emacs (easy) (04:37)
  • Launching Magit from IntelliJ IDEA - dolzhenko.me (@dsdolzhenko@fosstodon.org)
  • Plain Text Supremacy With Emacs: git-link, file-backed buffers, repo, daemons, auth-sources & pass (01:01:58)
  • Rahul Juliato: Custom VC-Focused Emacs Functions I Created to Enhance My Git Workflow
• Shells:
  • Tip about clearing the screen with comint-clear-buffer
• Web:
  • Emacs ウェブブラウザ 日本語マニュアルを見よう。 eww (無音） (02:45)
• Mail, news, and chat:
  • My Gnus Workflow For Working With iOS Notes – literatelisp.eu (@theesm@social.tchncs.de)
  • mastodon.el: extract toot URL (including boosts) and get local instance URL (@zrzz@fosstodon.org)
  • rtrppl/cuckoo-search: Content-based search for Elfeed (Irreal)
  • Sacha Chua: mastodon.el: Copy toot URL after posting; also, copying just this post with 11ty
  • Sacha Chua: Reading more blogs; Emacs Lisp: Listing blogs based on an OPML file
  • comint-histories version 2.0 released (Reddit)
• EXWM:
  • Cómo Usar Emacs como Entorno de Escritorio en Linux con EXWM - CIBERNINJAS
• Fun:
  • Flapping fish on your mode-line (Reddit)
• AI:
  • Automating Tasks with Emacs: Speech-to-Command Magic Explained (09:06)
  • Mastering Emacs: 🗣️ Speech Recognition & 🖐️ Interactive Task Creation Without a Keyboard! (03:38)
  • Ollama Buddy - Role Switching #emacs #ollama (02:02)
  • (udpate) Add AI summary generation to org-zettel-ref-mode
  • James Dyer: Ollama-Buddy 0.9.8: Transient Menu, Model Managing, GGUF Import, fabric Prompts and History Editing
• Community:
  • Local Emacs user group in Rome, Italy?
• Other:
  • To Emacs or Not to Emacs | HackerNoon
  • Small Emacs Tweaks — Where Are The Wise Men? (@mikehoss@appdot.net) - cleaning and formatting .env, eshell, highlight-symbol, wgrep
  • emacsomancer/pdffontetc: Emacs interface to pdffonts and other PDF metadata (Reddit)
  • Protesilaos Stavrou: Emacs: how I build from emacs.git on Debian stable
  • J.e.r.e.m.y B.r.y.a.n.t: Key layout with lower case parens and backspace on left
  • Emacs Caps Lock 問題 (無音) (03:51)
  • Android Emacs 31.0.50/Termux screencast, running Phel lisp PHP web application in localhost for development (@jasalt@fosstodon.org)
• Emacs development:
  • emacs-devel:
    • Re: Question about region caches - performance discussions
    • Re: Semantic: update or remove? - considering moving Semantic to ELPA?
    • Re: Semantic: update or remove? - might be worth seeing if someone can make a way to translate from Tree-sitter's grammar to Semantic's?
    • Re: font-lock apparently broken - if you use define-globalized-minor-mode, make sure you run-mode-hooks
  • checkdoc: Delete redundant check for wide docstrings
  • Remove ctags program
  • 'window-state-normalize-buffer-name' option for `uniquify' buffers
  • Adapt ediff to nonstandard layouts
  • Lazily highlight and insert candidates in Completions
  • Allow specifying in which major modes to enable 'global-hl-line-mode'
• New packages:
  • hugoista: Manage Hugo posts like a barista (GNU ELPA)
  • rg-themes: The rg theme collection (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, 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.

The next version of Denote is shaping up to be a huge one. One of the newest features I am working on is the support for “query links”. Those use the same denote: link type infrastructure but exhibit a different behaviour than the direct links we have always had. Instead of pointing to a file via its unique identifier, they initiate a search through the contents of all files in the denote-directory. This search uses the built-in Xref mechanism and is the same as what we have already been doing with backlinks (basically, a grep).

In short:

• Direct links: Those point to a file via its unique identifier. For example, denote:20250324T074132 resolves to a file path. Clicking on the link opens the corresponding file. Org export will also take care to turn this into a file path.
• Query links: Those do not point to any file per se. They are a string of one or more words or regular expression which is matched against the contents of files. For example, denote:this is a test produces a buffer listing all matches for the given query. Clicking on the matching line in that buffer opens the file at that point (just how our backlinks work when they show context—I am generalising this mechanism).

Direct links can point to any file, including PDFs, videos, and pictures (assuming it is renamed to use the Denote file-naming scheme). Whereas query links are limited to text files.

Development discussion and screenshots

This is a work-in-progress that lives on its own branch as of this writing. I will not elaborate at length right now as the implementation details may change. I have, nonetheless, created an issue on the GitHub repository where interested parties can provide their feedback. It also includes some screenshots I took: https://github.com/protesilaos/denote/issues/561. The code includes other changes which pertain to how we handle backlinks and constitutes a simplification of the code base.

The idea is to add the functionality to the main branch in the coming days or weeks. Then I will do a video about it and/or explain more.

That granted, do not forget that the official manual is the most up-to-date reference and the single source of truth.

Denote sources

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

[ Further down on this list I include more of my Denote-related packages. ]

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

Over at the Emacs subreddit, weevyl talks about how Emacs completion changed his life. Or at least his Emacs life. His story is about his repeated efforts to move to Emacs and always failing. He finally realized that the reason for his failures was the difficulty of learning and remembering command names. We’ve all been there. You load a new package and suddenly you have some new commands to remember.

Weevyl’s epiphany was that command completion can virtually eliminate this problem. He’s a Helm user but the same principals apply to Ivy and other such packages. When you start to type a command name, you get a list of completions to help you choose the right one. I’m not a Helm user but with Ivy, the search is fuzzy and it’s often enough to start with the package name to get a list of available commands.

I use this all the time and have long since stopped thinking about it but weevyl’s post made me realize what a powerful facility this completion is. You don’t have to try to remember a long list of commands or their bindings. As I said, it’s usually enough to remember the package name to get a list of commands that make it easy to narrow down to the desired target.

There’s lots of agreement in the comments. Several people have almost the same story. Others have written some Elisp to help with this and shared their code so if you’re also finding remembering Emacs command names daunting, take a look at the post. It’s easy to forget how much Emacs does—or can do—to make our workflow easier.

Over that the Emacs reddit, arni_ca asks about key bindings for cursor movement. It’s not quite clear what he’s asking but the theme is moving the cursor without bindings like Ctrl+f, Ctrl+b,
Meta+f,
Meta+b,
Ctrl+n, and Ctrl+p.

As is often the case, all the juice is in the comments. It’s astounding how many different strategies people have for such movements. They range from everything to using the arrow keys to custom Elisp snippets. Take a look at the post to see if any of the ideas will work for you.

By now, you all know my answer to questions like this. I started with this epiphany from Steve Yegge: large scale navigation—more than a few characters or lines—should be made with search. It’s perfectly obvious but it occurs to few of us until someone points it out. The wonderful avy package refines this strategy and offers finer grained control of where the cursor ends up. Avy is probably my most used set of commands. I use them constantly as I write and edit. Following Karthinks, I’ve mostly pared my use down to avy-goto-char-timer although I do sometimes still use avy-goto-word-1. Regardless, if you aren’t already using Avy, you should take a look. It’s the backbone of my navigation.

The other navigation tool I use is an import from Vim: jump-char that lets you jump to the next or previous instance of a character. It’s incredibly useful and, again, I use it several times a day. If you use Avy and Jump-char, you will have most of your navigation needs met.

I have been following the master branch of the emacs.git repository for many years now. It helps me test new features and make necessary adjustments to all the packages I develop/maintain. Below I explain how I make this happen on my computer, which is running Debian stable (Debian 12 “Bookworm” as of this writing). If you are a regular user, there is no reason to build from source: just use the latest stable release and you should be fine.

Configure the apt development sources

To build Emacs from source on Debian, you first need to have the deb-src package archive enabled. In your /etc/apt/sources.list file you must have something like this:

deb http://deb.debian.org/debian/ bookworm main
deb-src http://deb.debian.org/debian/ bookworm main

After modifying the sources, run the following on the command line to fetch the index with new package names+versions:

sudo apt update

Get the Emacs build dependencies

Now that you have enabled the deb-src archive, you can install the build dependencies of the Debian emacs package with the following on the command line:

sudo apt build-dep emacs

With this done, you are ready to build Emacs from source.

Get the Emacs source code

You need the git program to get the source code from the emacs.git website. So install it with this command:

sudo apt install git

Now make a copy of the Emacs source code, using this on the command line:

git clone https://git.savannah.gnu.org/git/emacs.git ~/path/to/my/copy-of-emacs.git

Replace ~/path/to/my/copy-of-emacs.git with the actual destination of your preference. I have a ~/Builds directory where I store all the projects I build from source. I thus do:

git clone https://git.savannah.gnu.org/git/emacs.git ~/Builds/emacs.git

If the cloning process is too slow on your end, perform a shallow clone instead. For example:

git clone --depth 1 https://git.savannah.gnu.org/git/emacs.git ~/Builds/emacs.git

And if the Savannah website is not responsive, then clone from the GitHub mirror (with the --depth 1 if necessary):

git clone https://github.com/emacs-mirror/emacs.git ~/Builds/emacs.git

Switch to the Emacs directory

Assuming you have the copy of emacs.git stored at ~/Builds/emacs.git, you switch to that directory with the following:

cd ~/Builds/emacs.git

Keep in mind that unless you explicitly switch to another branch, you are on master, i.e. the latest development target.

NOTE: All subsequent commands are ran from your equivalent of ~/Builds/emacs.git.

Run the autogen.sh the first time

This script will generate the configuration scaffold. You only really need to do this once (and I always forget about it for this very reason). Simply do this on the command line:

./autogen.sh

It checks that you have all you need to get started and prints output like this:

Checking whether you have the necessary tools...
(Read INSTALL.REPO for more details on building Emacs)
Checking for autoconf (need at least version 2.65) ... ok
Your system has the required tools.
Building aclocal.m4 ...
Running 'autoreconf -fi -I m4' ...
Building 'aclocal.m4' in exec ...
Running 'autoreconf -fi' in exec ...
Configuring local git repository...
'.git/config' -> '.git/config.~1~'
git config transfer.fsckObjects 'true'
git config diff.cpp.xfuncname '!^[ 	]*[A-Za-z_][A-Za-z_0-9]*:[[:space:]]*($|/[/*])
^((::[[:space:]]*)?[A-Za-z_][A-Za-z_0-9]*[[:space:]]*\(.*)$
^((#define[[:space:]]|DEFUN).*)$'
git config diff.elisp.xfuncname '^\([^[:space:]]*def[^[:space:]]+[[:space:]]+([^()[:space:]]+)'
git config diff.m4.xfuncname '^((m4_)?define|A._DEFUN(_ONCE)?)\([^),]*'
git config diff.make.xfuncname '^([$.[:alnum:]_].*:|[[:alnum:]_]+[[:space:]]*([*:+]?[:?]?|!?)=|define .*)'
git config diff.shell.xfuncname '^([[:space:]]*[[:alpha:]_][[:alnum:]_]*[[:space:]]*\(\)|[[:alpha:]_][[:alnum:]_]*=)'
git config diff.texinfo.xfuncname '^@node[[:space:]]+([^,[:space:]][^,]+)'
Installing git hooks...
'build-aux/git-hooks/commit-msg' -> '.git/hooks/commit-msg'
'build-aux/git-hooks/pre-commit' -> '.git/hooks/pre-commit'
'build-aux/git-hooks/prepare-commit-msg' -> '.git/hooks/prepare-commit-msg'
'build-aux/git-hooks/post-commit' -> '.git/hooks/post-commit'
'build-aux/git-hooks/pre-push' -> '.git/hooks/pre-push'
'build-aux/git-hooks/commit-msg-files.awk' -> '.git/hooks/commit-msg-files.awk'
'.git/hooks/applypatch-msg.sample' -> '.git/hooks/applypatch-msg'
'.git/hooks/pre-applypatch.sample' -> '.git/hooks/pre-applypatch'
You can now run './configure'.

Do not be intimidated by it. Focus on the final line instead, which directs you to the configure directive.

Explore the build flags

How exactly you build Emacs depends on your preferences and system-specific requirements. At the end of this post, I copy my current configuration, though I advise against copying it without understanding what it does.

If you have no specific preferences, just use the defaults by running this on the command line:

./configure

It will set up the build environment for you. If, however, you wish to explore your options and customise the emacs program you will get, then issue the following command and carefully read its output:

./configure --help

The minimum I recommend is to specify where the build artefacts are stored. I use this, which has not caused me any issues over the years:

./configure --prefix=/usr/local

Configure the build environment with your preferred flags

Once you have understood the available options, go ahead and run configure. For example:

./configure --prefix=/usr/local --with-x-toolkit=gtk3

Whenever you need to rebuild Emacs with some new flags, run the configure command again, passing it the relevant flags. If you wish to keep the same options for a new build, then simply do not run configure again.

Make the program

Once configure finishes its work, it is time to run the make program. For new builds, this is as simple as:

make

Sometimes you have old build artefacts that conflict with changes upstream. When that happens, the build process will fail. You may then need to use:

make bootstrap

In general, make is enough. It will be slow the first time, but will be faster on subsequent runs as it reuses what is already there. A make bootstrap will always be slow though, as it generates everything anew.

Install the program that was made

After make is done, you are ready to install Emacs:

sudo make install

You will not need escalated privileges (i.e. sudo) is you specified a --prefix with a user directory during the configure step. How you go about it is up to you.

Keeping Emacs up-to-date

Whenever you wish to update from source, go to where your copy of emacs.git is (e.g. ~/Builds/emacs.git) and pull the latest changes using the git program:

git pull

Then repeat make and make install. Remember that you do not need to re-run configure unless you specifically want to modify your build (and if you do that, you probably need to make bootstrap).

Learn about the latest NEWS

Emacs users can at all times learn about changes introduced in their current version of Emacs with M-x view-emacs-news. It is bound to the key C-h n by default. This command opens the current NEWS file. With a numeric prefix argument, you get the NEWS of the given Emacs version. For example, C-u 27 C-h n shows you what Emacs version 27 introduced.

Compare your NEWS to those of emacs.git

With the help of the built-in Emacs ediff package, you can compare your latest NEWS to those coming from emacs.git. I always do this after pulling the latest changes from source (with git pull).

From the root directory of your copye of emacs.git (e.g. ~/Builds/emacs.git), and while using Emacs, you can do M-x project-find-file (C-x p f) to search the Emacs “project” for a file called etc/NEWS. This is where the latest user-facing changes are recorded.

If you are not sure where you are on the filesystem while inside Emacs, do M-x cd (or M-x dired or M-x find-file), select the root directory of your emacs.git, hit RET, and then do M-x project-find-file.

Now that you have emacs.git/etc/NEWS in a buffer, also load your copy of NEWS with M-x view-emacs-news (C-h n).

Then do M-x ediff-buffers, which will prompt for two buffers to compare. First select your version of NEWS and then that of emacs.git.

NOTE: I think the default Ediff interface is problematic. Put the following in your configuration to make it work in a single frame:

(setq ediff-split-window-function 'split-window-horizontally)
(setq ediff-window-setup-function 'ediff-setup-windows-plain)

Also watch my video with the Ediff basics: https://protesilaos.com/codelog/2023-11-17-emacs-ediff-basics/.

This is it. You are now in the flow of building Emacs from source. Good luck with everything!

My current build options

--prefix=/usr/local --without-xinput2 --without-compress-install --without-gpm --without-selinux --with-native-compilation=yes --with-sound=no --without-gif --without-tiff --with-cairo --with-harfbuzz --with-tree-sitter=ifavailable --with-json --without-gsettings --without-gconf --with-x-toolkit=no --without-toolkit-scroll-bars --without-xft --without-xaw3d

I am not updating old publications, unless otherwise noted. The most up-to-date recode of my Emacs build is documented in my dotemacs: https://protesilaos.com/emacs/dotemacs.

Inspect the value of the Emacs variable system-configuration-options to find out how your Emacs is built.

Have fun!