Planet Emacslife

One of the most fun things you can do with Emacs is to build an interface for another piece of software. It is the Lisp version of running Doom on any device. It is also quite useful, because you can connect it to other tools in the gnu's editor and build more pleasant workflows.

The big question: can I chat on WhatsApp from Emacs? Spoiler: I made it, with some limitations.

No way in

Context: I work on macOS. It matters, because the solution depends on it.

Meta offers no API for this, and the macOS desktop app has no bridge at all: no open ports, no gRPC, no AppleScript dictionary. Nothing.

There are unofficial clients, like whatsmeow, that talk directly to WhatsApp's servers by pretending to be a device. They work, but your account ends up depending on software Meta does not authorize, and it is one more process to maintain. On top of that, Meta can detect them and ban your number. I am not going to risk my account just to chat from Emacs.

So how do you talk to an app that does not want to talk to you? By reading the same thing it reads.

Reading: the database

The WhatsApp app stores every chat in a local SQLite file:

~/Library/Group Containers/group.net.whatsapp.WhatsApp.shared/ChatStorage.sqlite

Emacs 29 ships with SQLite built in, no external libraries. Opening it read-only takes one line:

(sqlite-open file t)

The schema is undocumented, so I had to explore it by hand. Chats live in ZWACHATSESSION, messages in ZWAMESSAGE, and group member names in ZWAGROUPMEMBER and ZWAPROFILEPUSHNAME. That Z at the start of every name gives it away: it is a Core Data database.

And Core Data has a surprise. Dates do not count from 1970, but from January 1, 2001. My first messages showed up dated 1995. The fix: a constant.

(defconst whatsapp--epoch-offset 978307200
  "Seconds between the Unix epoch and the Core Data epoch (2001-01-01).")

There were more traps. Pinned chats store a date in the future so they stay on top, and the text of the session's last message is encoded. Better to read both from the message itself.

One more detail: macOS protects that directory. You have to give Emacs Full Disk Access in the privacy settings. I would hand Emacs the keys to my house if it asked.

Sending: the Shortcuts trick

Reading is easy. What about writing? Editing the database is pointless: the app would not notice and nothing would go out over the network.

Then I remembered that the WhatsApp app provides an action in macOS Shortcuts: "Send Message". And Shortcuts can be run from the terminal:

shortcuts run "Send WhatsApp" --input-path message.json

The problem is that the action expects a contact from your address book, not a number. The trick: build a vCard on the fly with the chat's phone number, which the shortcut turns into a temporary contact. Nothing is saved in your address book.

Emacs writes a JSON file with the vCard and the text, starts the process and waits:

(json-encode
 `((vcard . ,(whatsapp--vcard name phone))
   (text . ,text)))

The full flow looks like this:

flowchart LR
    E[Emacs] -- reads --> DB[(ChatStorage.sqlite)]
    E -- JSON with vCard --> S[Send WhatsApp shortcut]
    S -- Send Message --> W[Official WhatsApp app]
    W -- stores --> DB

I like one detail. While the shortcut runs, the message shows as (sending...). When WhatsApp stores it in its database, Emacs replaces it with the real one. What you see is what WhatsApp actually sent, not what Emacs thinks it sent.

The result

An ERC or rcirc style interface, with a chat list and one buffer per conversation:

--- Wednesday  1 October 2026 ---
[08:15] <Alice> Good morning!
[08:16] <Me> Morning! Are we still on for today?
[08:20] <Alice> Yes, 10:00 at the station
[08:21] <Alice> [image] This is the entrance
Alice> _

This is the most trivial part of the whole thing. Emacs solved this problem decades ago.

The whole client fits in a few lines of Elisp, with no dependencies.

It has its limits, of course.

• It only works on macOS.
• You cannot write to groups, because the Shortcuts action only accepts people.
• Some chats do not store the phone number locally and stay read-only.
• And there are no notifications: you press C-c C-u to fetch new messages.

But now I can talk to my family without leaving Emacs. What more could you ask for?

Sources

• whatsapp.el, the code and the instructions to create the shortcut.
• SQLite in Emacs, native support since Emacs 29.
• Shortcuts from the command line, Apple's documentation for the shortcuts command.
• vCard 3.0 (RFC 2426), the contact format the trick relies on.

Help me keep writing Every coffee gives me a push toward the next article. Sure, it's on me!

Send an email to comment+article-782e8f3b@andros.dev to leave a comment. The subject will be ignored.

The default keybinding of org-todo is C-c C-t. Today I learned about another command with a similar keybinding (C-c C-x C-t) -- org-toggle-timestamp-overlays. Note the C-x in the middle.

When I pressed that key combination (inadvertently), all the YYYY-MM-DD timestamps in the buffer were converted to the MM/DD/YYYY format. This was unacceptable -- I needed to change them back. However undo did not revert the timestamps; it just undid the last edit. Furthermore, these undesired timestamps couldn't be edited and were impervious to org-shiftright. I was confused yet again.

I didn't even know how this happened. So I invoked view-lossage as a kind reader once suggested ¹ and discovered org-toggle-timestamp-overlays.

The docstring was no help – it's self-evident that it would "Toggle the use of custom time stamp formats." Eager to clock out of my task, I didn't care to learn more. All I wanted to do was undo the effect.

I figured that since it toggles the timestamp, all I had to do was invoke it again to toggle it back. Nope. Well, a nice message appears, saying "Time stamp overlays removed." Yet the timestamps looked the same.

Undaunted, I figured I'd reload the buffer with org-mode-restart. That had no effect. To finally fix this, I deleted the buffer and revisited the file.

A command like this surely is in the same category as upcase-region, which is disabled by default. And so this is why I added (put 'org-toggle-timestamp-overlays 'disabled t) to my init file.

¹ See https://ray-on-emacs.blogspot.com/2026/05/emacs-view-commands.html

Intro

Quick, what does this match?

/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;

// Take
// your
// time...
//
// ...still decoding?
//
// OK, keep reading :)

That's the official regexp from semver.org. It validates version numbers like:

// matches
"1.2.3"
"0.10.0"
"2.0.0-rc.1"
"1.0.0-alpha.1+build.5"
"1.0.0+20260930"

// doesn't match
"01.2.3"   // leading zero
"1.2"      // missing patch
"v1.2.3"   // no "v" prefix allowed
"1.0.0-01" // numeric pre-release with a leading zero
"1.2.3-"   // empty pre-release

Don't get me wrong, I love regexps, but in practice you probably spend a bunch of time writing one, testing it against some cases, and moving on, proud of your achievement!

Some time passes and lucky future you (or unlucky someone else) has to change it. Dramatic pause here.

I bet you've been there. Now your options are probably: decode it again from the start, rewrite the whole thing, or, in the age of AI, ask (and hopefully not blindly accept) an LLM for a new recipe.

Emacs has had a nice answer for more readable regexps for a long time: the rx macro. I started using it all the time in Emacs Lisp, as reviewers always suggested it to me. Later, I started missing this DSL in JavaScript and TypeScript, so I wrote a small version of it for my projects.

So, what about reading that SemVer regexp like semver in the code below?

const num = or("0", seq(anyOf("1-9"), zeroOrMore(digit)));
const idChar = anyOf(alnum, "-");
const preId = or(num, seq(zeroOrMore(digit), anyOf(alpha, "-"), zeroOrMore(idChar)));
const dotted = (x: Item) => seq(x, zeroOrMore(".", x));

const semver = RX(
  start,
  named("major", num), ".",
  named("minor", num), ".",
  named("patch", num),
  optional("-", named("pre", dotted(preId))),
  optional("+", named("build", dotted(oneOrMore(idChar)))),
  end,
);

The same strings match, and you get named groups as a bonus. By the end of this post you'll know every piece of it.

TL;DR: jump straight to the cheat sheet, the side-by-side examples, the full source, or grab the gist to sneak a peek at the result.

NOTE: the RX here has nothing to do with RxJS, which is an amazing library for reactive programming with observables.

A taste of rx in Emacs Lisp

With rx you describe a regexp as a tree of named forms, and Emacs turns it into the regexp string for you:

(rx bos (+ digit) eos)
;; => "\\`[[:digit:]]+\\'"

(rx bol "colo" (? "u") "r" eol)
;; => "^colou?r$"

(rx bos "(" (= 3 digit) ")" space (= 3 digit) "-" (= 4 digit) eos)
;; => "\\`([[:digit:]]\\{3\\})[[:space:]][[:digit:]]\\{3\\}-[[:digit:]]\\{4\\}\\'"

A few things to notice:

1. Strings are literals. "(" means a parenthesis. You don't need to escape anything by hand.
2. Sequence is implicit. Every form takes a list of things and matches them one after the other. You don't need to wrap them in a seq, even though seq exists.
3. Groups appear only when needed. (+ digit) becomes [[:digit:]]+, not \(?:[[:digit:]]\)+.

The proposed JavaScript/TypeScript version in this post reads like this:

const phone = RX(
  start, "(", repeat(3, digit), ")", space,
  repeat(3, digit), "-", repeat(4, digit), end,
);
// => /^\(\d{3}\)\s\d{3}-\d{4}$/

Under the hood

If you want strings to be literals, you can't represent a regexp piece as a plain string, otherwise you can't tell "(" (a literal parenthesis) apart from "(?:...)" (a group you built). So every piece is a small object:

type Kind = "atom" | "seq" | "alt";

interface RxNode {
  readonly src: string;
  readonly kind: Kind;
  readonly set?: string; // char sets only, see below
  readonly neg?: boolean;
}

type Item = string | RxNode;

src is the regexp text. kind records how that text behaves when you glue it to other things:

• atom: a single unit, like a, \d, [a-z] or (...). You can put a quantifier right after it.
• seq: safe to concatenate, but a quantifier needs (?:...) around it. abc is a seq, and so is a+, since a+? would silently turn into a lazy quantifier.
• alt: has a | at the top level, so it needs (?:...) almost everywhere.

Plain strings go through literal, which escapes them:

const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

const literal = (s: string): RxNode => ({
  src: esc(s),
  kind: s.length === 1 ? "atom" : "seq",
});

const toNode = (x: Item): RxNode => (typeof x === "string" ? literal(x) : x);

With that in place, seq joins nodes and only brackets alternations:

const seq = (...xs: Item[]): RxNode => {
  const nodes = xs.map(toNode).filter((n) => n.src !== "");
  if (nodes.length === 0) return { src: "", kind: "seq" };
  if (nodes.length === 1) return nodes[0];

  let src = "";
  for (const n of nodes) {
	const part = n.kind === "alt" ? `(?:${n.src})` : n.src;
	// `\1` followed by a literal `0` would read as `\10`
	if (/\\\d+$/.test(src) && /^\d/.test(part)) src += "(?:)";
	src += part;
  }
  return { src, kind: "seq" };
};

(That backreference check is one of those bugs you only find by writing tests, or when it happens to you in prod. backref(1) followed by the literal "0" gives you backreference number ten.)

Every quantifier is a seq of its arguments plus a suffix, bracketed only when the body isn't an atom:

const quantifiable = (n: RxNode) =>
  n.kind === "atom" ? n.src : `(?:${n.src})`;

const quantifier =
  (suffix: string) =>
  (...xs: Item[]): RxNode => ({
	src: quantifiable(seq(...xs)) + suffix,
	kind: "seq",
  });

const zeroOrMore = quantifier("*");
const oneOrMore = quantifier("+");
const optional = quantifier("?");

Because each quantifier calls seq on its arguments, you get the implicit sequence for free: optional("-", group(x)) becomes (?:-(x))?.

And finally, the two entry points. As in Emacs, rx returns a string. RX returns a RegExp you can use right away:

const rx = (...xs: Item[]): string => seq(...xs).src;

function RX(...xs: Item[]): RegExp {
  return new RegExp(rx(...xs));
}

RX.flags = (flags: string, ...xs: Item[]): RegExp =>
  new RegExp(rx(...xs), flags);

RX.flags exists because Emacs controls case folding through the case-fold-search variable, and JavaScript puts it on the regexp itself.

That's the whole engine! Now, let's build our vocabulary.

Character sets

In Emacs you write (any "a-z" "_"). Inside those strings, a-z is a range, and a - at either end is a plain dash. I kept the same rule:

const hexDigit = anyOf("0-9a-fA-F");
RX(start, "#", repeat(6, hexDigit), end);
// => /^#[0-9a-fA-F]{6}$/

RX(start, optional(anyOf("+-")), oneOrMore(digit), end);
// => /^[+\-]?\d+$/

The dash comes out escaped because sets can merge. If you combine anyOf("+-") with anyOf("0-9"), an unescaped - would end up in the middle and create a range from + to 0. Escaping it costs one backslash.

And merging is the reason why RxNode has a set field. It is there to hold the text that goes between [ and ], so anyOf can take other sets as arguments:

const lower = anyOf("a-z");
const upper = anyOf("A-Z");
const alpha = anyOf(lower, upper);   // [a-zA-Z]
const alnum = anyOf(alpha, "0-9");   // [a-zA-Z0-9]

not negates a set, and it knows the shorthand classes:

not(digit);                // \D
not(anyOf(space, "@"));    // [^\s@]
notChar(",");              // [^,]   (rx's not-char)

The simple email check, which most of us have written as /^[^\s@]+@[^\s@]+\.[^\s@]+$/ at some point, becomes:

const part = oneOrMore(not(anyOf(space, "@")));

RX(start, part, "@", part, ".", part, end);
// => /^[^\s@]+@[^\s@]+\.[^\s@]+$/

The rest of the Emacs character classes are there too: digit, hexDigit, space, blank, wordChar, notWordChar, alpha, alnum, lower, upper, punct, control, graphic, printing, ascii and nonascii. One difference: in Emacs they understand Unicode, and mine are ASCII only. alpha won't match é.

Two more come from rx's symbol list, and people (me, many times) mix them up:

const notNewline: RxNode = { src: ".", kind: "atom" }; // rx: nonl
const anything = set("\\s\\S");                        // rx: anything / anychar

In rx, anything really means anything, newlines included. Here is where the difference shows up:

const code = "a = 1; /* first\n   second */ b = 2;";

RX("/*", zeroOrMoreLazy(notNewline), "*/").exec(code);
// => null

RX("/*", zeroOrMoreLazy(anything), "*/").exec(code)?.[0];
// => "/* first\n   second */"

Alternatives, and the longest match

or works as you'd expect, and gets bracketed when it lands inside a sequence:

RX(start, or("cat", "dog", "bird"), end);
// => /^(?:bird|cat|dog)$/

Did you notice the order changed? I copied that behavior from Emacs. When every branch of an or is a plain string, rx hands them to regexp-opt, which builds a pattern that prefers the longest match:

(rx (or "in" "int" "interface"))
;; => "\\(?:in\\(?:t\\(?:erface\\)?\\)?\\)"

JavaScript alternation takes the first branch that matches, going left to right. So the naive regexp for a list of keywords has a 'bug':

/in|int|interface/.exec("interface Foo")?.[0];
// => "in"

RX(or("in", "int", "interface")).exec("interface Foo")?.[0];
// => "interface"

I don't build a trie like regexp-opt does. Sorting the strings by length, longest first, is enough to get the same behavior:

const or = (...xs: Item[]): RxNode => {
  if (xs.length === 0) return unmatchable;
  if (xs.length === 1) return toNode(xs[0]);

  const branches = xs.every((x) => typeof x === "string")
	? [...(xs as string[])].sort((a, b) => b.length - a.length)
	: xs;

  return { src: branches.map((x) => toNode(x).src).join("|"), kind: "alt" };
};

As in Emacs, or() with no branches returns unmatchable, which is (?!) here. It's handy when you build the branch list at runtime and it might come out empty.

Repetition, greedy and lazy

Emacs has (= n ...), (>= n ...) and (** n m ...). Here they are repeat, atLeast and between:

RX(start, between(2, 4, digit), end);  // /^\d{2,4}$/
RX(atLeast(3, digit));                 // /\d{3,}/

The lazy versions *?, +? and ?? are zeroOrMoreLazy, oneOrMoreLazy and optionalLazy. The classic HTML tag example:

const html = "<b>bold</b> and <i>italic</i>";

RX("<", oneOrMore(notNewline), ">").exec(html)?.[0];
// => "<b>bold</b> and <i>italic</i>"

RX("<", oneOrMoreLazy(notNewline), ">").exec(html)?.[0];
// => "<b>"

Groups and backreferences

group is a capturing group, and backref points back to it:

RX(start, group(oneOrMore(wordChar)), space, backref(1), end);
// => /^(\w+)\s\1$/   matches "hello hello", not "hello world"

Emacs also has (group-n N ...) to pick the group number. JavaScript can't do that, but it has named groups, which serve the same purpose and read better:

const date = RX(
  named("y", repeat(4, digit)), "-",
  named("m", repeat(2, digit)), "-",
  named("d", repeat(2, digit)),
);

date.exec("2026-09-30")?.groups;
// => { y: '2026', m: '09', d: '30' }

backref accepts a name as well:

RX(
  "<", named("tag", oneOrMore(wordChar)), ">",
  zeroOrMoreLazy(notNewline),
  "</", backref("tag"), ">",
);
// => /<(?<tag>\w+)>.*?<\/\k<tag>>/

Anchors

rx distinguishes the start of the string (bos) from the start of a line (bol). In JavaScript both are ^, and the m flag decides which one you get. I kept both names so the intent shows in the code:

const text = "TODO: write post\nDONE: fix rx\nTODO: publish";
const todo = RX.flags(
  "gm",
  lineStart, "TODO: ", named("task", oneOrMore(notNewline)), lineEnd,
);

[...text.matchAll(todo)].map((m) => m.groups?.task);
// => [ 'write post', 'publish' ]

Why not add start and end automatically? Because you only want them when validating a whole string. When searching inside a text, as in split, replace or matchAll, a hidden ^ and $ would break everything. Emacs agrees: bos and eos are explicit in rx too.

wordBoundary and notWordBoundary map straight to \b and \B. Emacs also has bow and eow (\< and \>), start and end of a word. JavaScript lacks those, so I combined \b with a lookaround:

const wordStart = zeroWidth("\\b(?=\\w)");
const wordEnd = zeroWidth("\\b(?<=\\w)");

Literal and raw

Plain strings are already literals, but rx has an explicit literal form for strings computed at runtime, and I kept it. It documents that the value came from somewhere else:

const userInput = "1+1=2? (maybe)";

new RegExp(userInput).test(userInput);  // false, oops
RX(literal(userInput)).test(userInput); // true

The opposite direction is rx's (regexp ...) form, the escape hatch. Here it's raw, and it receives either a string or an existing RegExp. It lets you adopt the DSL in a codebase full of old regexps without rewriting all of them, like:

const legacyZip = /\d{5}(?:-\d{4})?/;

RX(start, repeat(2, upper), " ", raw(legacyZip), end);
// => /^[A-Z]{2} (?:\d{5}(?:-\d{4})?)$/

raw can't see inside the text it gets, so it adds brackets whenever it's combined with something else. It's an extra (?:), and the regexp still works.

Shall we try SemVer again?

Back to the regexp from the intro. In Emacs you would give names to the pieces with rx-define or rx-let. In TypeScript those are just consts:

const num = or("0", seq(anyOf("1-9"), zeroOrMore(digit)));
const idChar = anyOf(alnum, "-");
const preId = or(num, seq(zeroOrMore(digit), anyOf(alpha, "-"), zeroOrMore(idChar)));
const dotted = (x: Item) => seq(x, zeroOrMore(".", x));

const semver = RX(
  start,
  named("major", num), ".",
  named("minor", num), ".",
  named("patch", num),
  optional("-", named("pre", dotted(preId))),
  optional("+", named("build", dotted(oneOrMore(idChar)))),
  end,
);

Now you can read the spec in the code. A numeric identifier is 0, or a non-zero digit followed by any number of digits. A pre-release is a dotted list of identifiers, and so is build metadata. dotted is a plain function returning a node, which is as far as abstraction needs to go here.

It matches the same strings as the official regexp, and the named groups give you a result like:

semver.exec("1.0.0-alpha.1+build.5")?.groups;
// => {
//   major: '1',
//   minor: '0',
//   patch: '0',
//   pre: 'alpha.1',
//   build: 'build.5'
// }

Next time the spec changes, you can understand what the current regex does at a glance, instead of fighting an army of punctuation.

What's missing from Emacs rx

I tried to map every rx form, and a few have no JavaScript equivalent:

• point: JavaScript regexps don't know about a cursor.
• symbol-start, symbol-end, syntax, category: these depend on Emacs syntax tables.
• intersection: possible with the v flag, but I haven't needed it.
• minimal-match / maximal-match: these flip the greediness of everything inside them. Doable, but it would need a separate pass, and the *Lazy functions cover my use cases.
• eval: TypeScript already evaluates expressions everywhere, so you get it for free.

And one addition Emacs doesn't need: RX.flags.

Cheat sheet

Examples: JS/TS regex vs RX

Each example below shows the goal, the Emacs rx form in a comment, the regexp you would write by hand, and the RX version. When RX produces a different regexp text, the // => line shows it. The results at the bottom come from running both against the same strings.

Digits only

The whole string is digits.

// Emacs: (rx bos (+ digit) eos)
const regex = /^\d+$/;
const dsl = RX(start, oneOrMore(digit), end);

// "123" -> true
// "12a" -> false

Letters only

The whole string is ASCII letters.

// Emacs: (rx bos (+ alpha) eos)
const regex = /^[a-zA-Z]+$/;
const dsl = RX(start, oneOrMore(alpha), end);

// "Hello" -> true
// "He11o" -> false

Optional letter

Both spellings, color and colour.

// Emacs: (rx bos "colo" (? "u") "r" eos)
const regex = /^colou?r$/;
const dsl = RX(start, "colo", optional("u"), "r", end);

// "color" -> true
// "colour" -> true
// "colouur" -> false

Two words

Two words separated by a space.

// Emacs: (rx bos (+ wordchar) space (+ wordchar) eos)
const regex = /^\w+\s\w+$/;
const word = oneOrMore(wordChar);
const dsl = RX(start, word, space, word, end);

// "hello world" -> true
// "hello" -> false

Phone number

(123) 456-7890, parentheses and all.

// Emacs: (rx bos "(" (= 3 digit) ")" space (= 3 digit) "-" (= 4 digit) eos)
const regex = /^\(\d{3}\)\s\d{3}-\d{4}$/;
const dsl = RX(
  start, "(", repeat(3, digit), ")", space,
  repeat(3, digit), "-", repeat(4, digit), end,
);

// "(123) 456-7890" -> true
// "123-456-7890" -> false

Hex color

#ff00aa-style colors.

// Emacs: (rx bos "#" (= 6 hex-digit) eos)
const regex = /^#[0-9a-fA-F]{6}$/;
const dsl = RX(start, "#", repeat(6, hexDigit), end);

// "#ff00aa" -> true
// "#ff00ag" -> false

Signed integer

An optional sign, then digits.

// Emacs: (rx bos (? (any "+-")) (+ digit) eos)
const regex = /^[+-]?\d+$/;
const dsl = RX(start, optional(anyOf("+-")), oneOrMore(digit), end);
// => /^[+\-]?\d+$/

// "-42" -> true
// "42" -> true
// "*42" -> false

Simple email

Something@something.something, no spaces.

// Emacs: (rx-let ((part (+ (not (any space "@")))))
//   (rx bos part "@" part "." part eos))
const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
const part = oneOrMore(not(anyOf(space, "@")));
const dsl = RX(start, part, "@", part, ".", part, end);

// "a@b.com" -> true
// "a b@c.com" -> false
// "a@b" -> false

No digits

A string without any digit.

// Emacs: (rx bos (+ (not digit)) eos)
const regex = /^[^\d]+$/;
const dsl = RX(start, oneOrMore(not(digit)), end);
// => /^\D+$/

// "abc" -> true
// "a1b" -> false

CSV line

Exactly three comma-separated fields.

// Emacs: (rx-let ((field (+ (not-char ","))))
//   (rx bos field "," field "," field eos))
const regex = /^[^,]+,[^,]+,[^,]+$/;
const field = oneOrMore(notChar(","));
const dsl = RX(start, field, ",", field, ",", field, end);

// "a,b,c" -> true
// "a,b," -> false

One of many

A fixed list of words.

// Emacs: (rx bos (or "cat" "dog" "bird") eos)
const regex = /^(?:cat|dog|bird)$/;
const dsl = RX(start, or("cat", "dog", "bird"), end);
// => /^(?:bird|cat|dog)$/

// "cat" -> true
// "bird" -> true
// "cow" -> false

Title and name

mr or ms, then a name, keeping the title.

// Emacs: (rx bos (group (or "mr" "ms")) space (+ wordchar) eos)
const regex = /^(mr|ms)\s\w+$/;
const dsl = RX(start, group(or("mr", "ms")), space, oneOrMore(wordChar), end);

// "mr john" -> true
// "dr john" -> false

Between

Two to four digits.

// Emacs: (rx bos (** 2 4 digit) eos)
const regex = /^\d{2,4}$/;
const dsl = RX(start, between(2, 4, digit), end);

// "12" -> true
// "12345" -> false

At least

Three or more digits, anywhere.

// Emacs: (rx (>= 3 digit))
const regex = /\d{3,}/;
const dsl = RX(atLeast(3, digit));

// "12" -> false
// "a123" -> true

Repeated word

The same word twice.

// Emacs: (rx bos (group (+ wordchar)) space (backref 1) eos)
const regex = /^(\w+)\s\1$/;
const dsl = RX(start, group(oneOrMore(wordChar)), space, backref(1), end);

// "hello hello" -> true
// "hello world" -> false

Matching tags

An open tag and its own closing tag.

// Emacs: (rx "<" (group-n 1 (+ wordchar)) ">" (*? nonl) "</" (backref 1) ">")
const regex = /<(?<tag>\w+)>.*?<\/\k<tag>>/;
const dsl = RX(
  "<", named("tag", oneOrMore(wordChar)), ">",
  zeroOrMoreLazy(notNewline),
  "</", backref("tag"), ">",
);

// "<b>bold</b>" -> true
// "<b>oops</i>" -> false

Whole word

cat as a word, not inside another one.

// Emacs: (rx word-boundary "cat" word-boundary)
const regex = /\bcat\b/;
const dsl = RX(wordBoundary, "cat", wordBoundary);

// "the cat sat" -> true
// "concatenate" -> false

Case-insensitive

hello, in any case.

// Emacs: (let ((case-fold-search t))
//   (string-match-p (rx bos "hello" eos) "HeLLo"))
const regex = /^hello$/i;
const dsl = RX.flags("i", start, "hello", end);

// "HeLLo" -> true
// "help" -> false

Full source

It's a single file with no dependencies. Copy it into your project and start deleting the forms you don't need, or adding the ones you miss.

You can check the same code, plus all the examples from this post (and a few more), in this gist. If you'd rather not set anything up, paste it into the TypeScript Playground, hit "Run", and check the "Logs" tab.

/* =========================================================
 * CORE
 * ========================================================= */

// How a node behaves when combined with others:
//   atom -> single unit, a quantifier can be glued right after it
//   seq  -> safe to concatenate, needs (?:) to be quantified
//   alt  -> has a top-level `|`, needs (?:) almost everywhere
type Kind = "atom" | "seq" | "alt";

interface RxNode {
  readonly src: string;
  readonly kind: Kind;
  // char sets only: the text that goes inside [ ], so sets can merge
  readonly set?: string;
  readonly neg?: boolean;
}

type Item = string | RxNode;

const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const escSet = (s: string) => s.replace(/[\]\\^-]/g, "\\$&");

// rx: (literal EXPR) — a string computed at runtime, matched as-is
const literal = (s: string): RxNode => ({
  src: esc(s),
  kind: s.length === 1 ? "atom" : "seq",
});

const toNode = (x: Item): RxNode => (typeof x === "string" ? literal(x) : x);

// wrap a node so a quantifier applies to all of it
const quantifiable = (n: RxNode) =>
  n.kind === "atom" ? n.src : `(?:${n.src})`;

// rx: (regexp EXPR) — escape hatch, trust the regexp as-is
const raw = (re: string | RegExp): RxNode => ({
  src: typeof re === "string" ? re : re.source,
  kind: "alt",
});

/* =========================================================
 * COMPOSITION
 * ========================================================= */

const seq = (...xs: Item[]): RxNode => {
  const nodes = xs.map(toNode).filter((n) => n.src !== "");
  if (nodes.length === 0) return { src: "", kind: "seq" };
  if (nodes.length === 1) return nodes[0];

  let src = "";
  for (const n of nodes) {
	const part = n.kind === "alt" ? `(?:${n.src})` : n.src;
	// `\1` followed by a literal `0` would read as `\10`
	if (/\\\d+$/.test(src) && /^\d/.test(part)) src += "(?:)";
	src += part;
  }
  return { src, kind: "seq" };
};

const unmatchable: RxNode = { src: "(?!)", kind: "atom" };

// Like rx: when every branch is a plain string, try the longest first,
// so or("in", "int") matches "int" instead of stopping at "in".
const or = (...xs: Item[]): RxNode => {
  if (xs.length === 0) return unmatchable;
  if (xs.length === 1) return toNode(xs[0]);

  const branches = xs.every((x) => typeof x === "string")
	? [...(xs as string[])].sort((a, b) => b.length - a.length)
	: xs;

  return { src: branches.map((x) => toNode(x).src).join("|"), kind: "alt" };
};

/* =========================================================
 * CHARACTER SETS
 * ========================================================= */

const set = (body: string, neg = false): RxNode => ({
  src: neg ? `[^${body}]` : `[${body}]`,
  kind: "atom",
  set: body,
  neg,
});

// class escapes are sets too, so they can go inside anyOf(...)
const classEscape = (e: string): RxNode => ({
  src: e,
  kind: "atom",
  set: e,
  neg: false,
});

// Same reading as rx: inside a string, "a-z" is a range, while a `-`
// at the start or end is just a dash ("+-" is plus or minus).
const intervals = (s: string): string => {
  let body = "";
  let i = 0;
  while (i < s.length) {
	if (i < s.length - 2 && s[i + 1] === "-") {
	  body += `${escSet(s[i])}-${escSet(s[i + 2])}`;
	  i += 3;
	} else {
	  body += escSet(s[i]);
	  i += 1;
	}
  }
  return body;
};

// rx: (any "a-z" "_" digit) — also known as `in` and `char`
const anyOf = (...xs: Item[]): RxNode => {
  const body = xs
	.map((x) => {
	  if (typeof x === "string") return intervals(x);
	  if (x.set === undefined || x.neg)
		throw new Error(`anyOf: not a positive char set: ${x.src}`);
	  return x.set;
	})
	.join("");
  return set(body);
};

// rx: (not charset) — not(digit) -> \D, not(anyOf(",;")) -> [^,;]
const not = (x: Item): RxNode => {
  const n = typeof x === "string" ? anyOf(x) : x;
  if (n.set === undefined) throw new Error(`not: not a char set: ${n.src}`);
  if (n.neg) return set(n.set);
  if (/^\\[dswDSW]$/.test(n.src)) {
	const c = n.src[1];
	const flipped = c === c.toLowerCase() ? c.toUpperCase() : c.toLowerCase();
	return classEscape(`\\${flipped}`);
  }
  return set(n.set, true);
};

// rx: (not-char "a-z" ...) — shorthand for (not (any ...))
const notChar = (...xs: Item[]) => not(anyOf(...xs));

// rx char classes, `[[:name:]]` in Emacs
const digit = classEscape("\\d");
const space = classEscape("\\s");
const wordChar = classEscape("\\w");
const notWordChar = not(wordChar);

const lower = anyOf("a-z");
const upper = anyOf("A-Z");
const alpha = anyOf(lower, upper);
const alnum = anyOf(alpha, "0-9");
const hexDigit = anyOf("0-9a-fA-F");
const blank = set(" \\t");
const control = set("\\x00-\\x1f\\x7f");
const punct = anyOf("!-/:-@[-`{-~");
const graphic = anyOf("!-~");
const printing = anyOf(" -~");
const ascii = set("\\x00-\\x7f");
const nonascii = set("\\u0080-\\uffff");

// rx: `nonl` is any char but newline; `anything` really is anything
const notNewline: RxNode = { src: ".", kind: "atom" };
const anything = set("\\s\\S");

/* =========================================================
 * ANCHORS (zero-width)
 * ========================================================= */

const zeroWidth = (src: string): RxNode => ({ src, kind: "seq" });

// rx: bos / eos
const start = zeroWidth("^");
const end = zeroWidth("$");
// rx: bol / eol — same symbols, only per line with the "m" flag
const lineStart = start;
const lineEnd = end;

const wordBoundary = zeroWidth("\\b");
const notWordBoundary = zeroWidth("\\B");
// rx: bow / eow — JS has no \< \>, so a boundary plus a lookaround
const wordStart = zeroWidth("\\b(?=\\w)");
const wordEnd = zeroWidth("\\b(?<=\\w)");

/* =========================================================
 * GROUPS & BACKREFERENCES
 * ========================================================= */

const group = (...xs: Item[]): RxNode => ({
  src: `(${seq(...xs).src})`,
  kind: "atom",
});

// rx has (group-n N ...); JS can't pick group numbers, but it can name them
const named = (name: string, ...xs: Item[]): RxNode => ({
  src: `(?<${name}>${seq(...xs).src})`,
  kind: "atom",
});

const backref = (ref: number | string): RxNode => ({
  src: typeof ref === "number" ? `\\${ref}` : `\\k<${ref}>`,
  kind: "atom",
});

/* =========================================================
 * QUANTIFIERS
 * ========================================================= */

const quantifier =
  (suffix: string) =>
  (...xs: Item[]): RxNode => ({
	src: quantifiable(seq(...xs)) + suffix,
	kind: "seq",
  });

// greedy — rx: * + ?
const zeroOrMore = quantifier("*");
const oneOrMore = quantifier("+");
const optional = quantifier("?");

// lazy — rx: *? +? ??
const zeroOrMoreLazy = quantifier("*?");
const oneOrMoreLazy = quantifier("+?");
const optionalLazy = quantifier("??");

// rx: (= n ...) (>= n ...) (** n m ...)
const repeat = (n: number, ...xs: Item[]) => quantifier(`{${n}}`)(...xs);
const atLeast = (n: number, ...xs: Item[]) => quantifier(`{${n},}`)(...xs);
const between = (n: number, m: number, ...xs: Item[]) =>
  quantifier(`{${n},${m}}`)(...xs);

/* =========================================================
 * ENTRY POINTS
 * ========================================================= */

// rx(...)  -> the regexp source string (like Emacs, rx returns a string)
// RX(...)  -> a ready-to-use RegExp, no more `new RegExp(seq(...))`
const rx = (...xs: Item[]): string => seq(...xs).src;

function RX(...xs: Item[]): RegExp {
  return new RegExp(rx(...xs));
}
// Emacs uses `case-fold-search` for this; JS puts it on the regexp
RX.flags = (flags: string, ...xs: Item[]): RegExp =>
  new RegExp(rx(...xs), flags);

Wrapping up

None of this is new. On the Emacs side, as I said before, rx has shipped for decades, and the Elisp version is more complete than mine.

The idea of describing patterns with a small DSL instead of raw syntax isn't new either. Plenty of people have tried it, each in their own way. One project I like a lot in this space is Zod, which I wrote about in my Zod quick tutorial. It's not a regexp builder: you compose small schema pieces, and Zod gives you back a parser and a TypeScript type from the same construction. It follows the same spirit, though: build big things out of small named pieces you can read.

If you write Elisp and have never tried rx, open *scratch*, type (rx (+ digit)), and C-x C-e it. If you write JavaScript or TypeScript, the file above is yours. And if you port it to another language, send me a link.

Over at the Emacs subreddit, BBSnek writes about discovering remember mode. It’s been around for a long time. I remember using it before Org mode. Indeed, I still use Ctrl+c r to invoke org-capture because that was what I was used to with remember-mode.

Although I’m sure there are some, I can’t think of any reason to use remember-mode these days. Org mode can do everything it can and more. Org’s templates make capturing data and notes so much easier and, of course, you can bring all the other Org tools to bear on the results.

BBSnek uses it for quick notes—and it’s great for that—but Org can do that too and so much more. The truth is, I’m surprised that anyone is still using it for any other reason than inertia. Still, as usual, Emacs lets us have it our way and for those who prefer the simpler and lighter weight remember-mode, it’s there for them.

Last December, I gave a talk at EmacsConf 2025 called “Zettelkasten for Regular Emacs Hackers”. I announced it back then, but never pointed to the recording. Here it is.

The pitch: writing improves the quality and depth of thought, and a Zettelkasten is an environment for thinking through writing, not merely a place to store notes. Nobody can hand you a finished thinking environment the way they can hand you an email client. You have to build your own, and Emacs is the most moldable place to do it.

In 23 minutes, I walk through:

• the three essential mechanics: write (with effort), connect (with links), and correct (improve notes as you learn more);
• the habits that make it scale over decades: design for use, create structure, start in the Zettelkasten, and start with a link;
• why “garbage in, garbage out” applies to notes, too;
• a live demo with a minimal init.el and Denote to create, link, rename, and backlink notes. Try it yourself with the configuration and the notes from the demo below.

Try it yourself

This is the whole configuration I used in the demo. Save it as init.el in an empty folder and launch Emacs from there:

$ emacs -nw --init-directory . init.el

(load-theme 'modus-vivendi-tinted)  ;; Dark theme to match dark slides
(menu-bar-mode -1)                  ;; Disable topmost menu bar

(package-refresh-contents)

(use-package denote
  :ensure t
  :hook (dired-mode . denote-dired-mode)
  :bind
  (("C-c n n" . denote)
   ("C-c n r" . denote-rename-file)
   ("C-c n l" . denote-link)
   ("C-c n c" . denote-link-after-creating)
   ("C-c n b" . denote-backlinks)
   ("C-c n d" . denote-dired)
   ("C-c n g" . denote-grep))
  :config
  (setq denote-directory (expand-file-name "./notes/"))

  ;; Automatically rename Denote buffers when opening them so that
  ;; instead of their long file name they have, for example, a literal
  ;; "[D]" followed by the file's title.  Read the doc string of
  ;; `denote-rename-buffer-format' for how to modify this.
  (denote-rename-buffer-mode 1))

;; For the demo, I forced notes to show in full screen by default.
(setopt display-buffer-alist nil)
(add-to-list 'display-buffer-alist
	     '("^\\[D\\] " ;; Denote buffer name prefix
	       (display-buffer-reuse-mode-window display-buffer-full-frame)
	       ))

The notes from the demo

These are the notes I wrote during the recording. The video runs them at 3 to 4 times the speed, so they’re easier to read here.

Mechanics and habits to use a Zettelkasten

#+title:      Mechanics and habits to use a Zettelkasten
#+date:       [2025-11-21 Fri 20:48]
#+filetags:   :zettelkasten:
#+identifier: 20251121T204827

Essential:
- Write: put in effort; [[denote:20251121T205045][GIGO]]
- Connect: Link notes to create trails
- Correct: Improve as you go

Additional:
- Design for use: give things a purpose, e.g. blog about it
- Create structure. [[denote:20251121T205312][Types of structures in a Zettelkasten]]: design new entry points and trails
- Start in the Zettelkasten: use the system to learn, make it grow, get better
- Start with a link: keeps your notes connected. [[denote:20251121T210416][Create notes as link first to avoid orphans]]

Tool doesn't matter as much. Small files are good. [[denote:20251121T210107][Use Denote in Emacs]]

(Christian Tietze: Zettelkasten for Regular Emacs Hackers, EmacsConf 2025)

Garbage in, garbage out

#+title:      Garbage in, garbage out
#+date:       [2025-11-21 Fri 20:50]
#+filetags:   :programming:quality:
#+identifier: 20251121T205045

The principle known as "Garbage In, Garbage Out" (GIGO) in computer
programming states that for any system, the quality of output is
directly depending on the quality of input.

See: https://en.wikipedia.org/wiki/Garbage_in,_garbage_out

Types of structures in a Zettelkasten

#+title:      Types of structures in a Zettelkasten
#+date:       [2025-11-21 Fri 20:53]
#+filetags:   :structure:zettelkasten:
#+identifier: 20251121T205312

Non-comprehensive list of structures that could be used in a Zettelkasten:

- Opposition pair: 1 note for the pair, 1 note per position/opposition each; pro/contra
- Table of contents: list of topics/headings
  - an outline for a writing project
  - recreation of a book's contents (so I can write in detail about the book);
- Argument: recreation of a distilled form to get to a conclusion;
  list premises and evidence, and how these support the conclusion
  - Counter-argument: address parts of the original argument to support another
    view and test the argument's strength
- Table of things
- Graphics, like a concept map, Mind-Map, diagram: visually bring
  elements into a relation, then write about the relation and the elements

Metaphors:
- Iceberg: visibile tip with hidden depth; someting that appears small
  but is large; good metaphor for obstacles
- Black box: focus on inputs and outputs, and ignore the 'how' in the middle
  - e.g. most Emacs Lisp functions (hoping the documentation is good)
- [[denote:20251121T205739][Atom, molecule, organism]]: how small parts compose to larger parts,
  which compose to even larger pieces
  
  
(Christian Tietze: Zettelkasten for Regular Emacs Hackers, EmacsConf 2025)

Atom, molecule, organism metaphor

#+title:      Atom, molecule, organism metaphor
#+date:       [2025-11-21 Fri 20:57]
#+filetags:   :composition:recursion:
#+identifier: 20251121T205739

Atom: smallest part, indivisible elements
Molecule: comprised of atoms; structure added to combine elements
Organism: comprised of molecules; different level of analysis, irreducible to molecules/atoms

This can be used e.g. for programming: functions compose into larger
functions which compose into packages.

Actual biological organisms also work in such a way. Organs are part
of bodily functions (high abstraction), but from a chemical or
physical perspective, you can decompose them into atoms. That doesn't
tell you anything about the organ's function.

Denote.el for Zettelkasten in Emacs

#+title:      Denote.el for Zettelkasten in Emacs
#+date:       [2025-11-21 Fri 21:01]
#+filetags:   :denote:emacs:zettelkasten:
#+identifier: 20251121T210107

While not shipping with Emacs out of the box, Denote is easy to install and a great start to manage notes:

- it comes with unified way to create new notes, and hides time-stamped ID's with "[D]" in buffer lists
- it can manage links, and show incoming links to notes ("backlinks")
- it supports quickly adding links, and creating links _first_ out of
  the box -- it just creates the note immediately, so you don't notice
  - [[denote:20251121T210416][Create notes as link first to avoid orphans]]

* Example configuration

#+BEGIN_SRC elisp
(use-package denote
  :ensure t
  :hook (dired-mode . denote-dired-mode)
  :bind
  (("C-c n n" . denote)
   ("C-c n r" . denote-rename-file)
   ("C-c n l" . denote-link)
   ("C-c n c" . denote-link-after-creating)
   ("C-c n b" . denote-backlinks)
   ("C-c n d" . denote-dired)
   ("C-c n g" . denote-grep))
  :config
  (setq denote-directory (expand-file-name "./notes/"))

  ;; Automatically rename Denote buffers when opening them so that
  ;; instead of their long file name they have, for example, a literal
  ;; "[D]" followed by the file's title.  Read the doc string of
  ;; `denote-rename-buffer-format' for how to modify this.
  (denote-rename-buffer-mode 1))
#+END_SRC

Create notes as link first to avoid orphans

#+title:      Create notes as link first to avoid orphans
#+date:       [2025-11-21 Fri 21:04]
#+filetags:   :linking:zettelkasten:
#+identifier: 20251121T210416

Recommended practice by Christian Tietze: start a new note with a link
first from some place, any place, then create the file to match that
link (which would initially lead nowhere).

- Reduces orphans in the Zettelkasten by guaranteeing every note to
  have at least one link.
- Supposedly teaches you to think about possible connections early,
  which makes the network better.

A very loosey-goosey approach, when taken literally and used
liberally: it doesn't matter where you are, just leave a forward link
to something you wish existed. Even if it doesn't fit the current
note. After all, you came up with the idea just now -- so maybe
there's a connection that you just can't spell out, yet?

Follow along

• Talk script (Org), if you’d rather read than watch.
• The Q&A session on YouTube, over an hour of questions and answers after the talk.
• The conference page with captions, chapters, and the shared notes pad.

If you want the general introduction without Emacs, zettelkasten.de is the place to start.

Get new posts delivered to your inbox — subscribe.

What I'm up to right now · Work with me · Apps

Charles Choi has been writing a bunch of nice little apps lately—more than I can cover. His latest, Aquí, is sort of a niche application but is potentially useful for more than just its intended use.

The back story is that Choi really likes the sunrise-sunset command in Emacs that tells him the times that the sun rises and sets. The problem is that sunrise-sunset requires that you first specify the latitude and longitude of where you want to know the times. The standard way of doing that is to record them in your init.el, which is what I do. Choi, however, travels with his laptop but still wants to know when the sun is coming up or going down. There’s no automatic way of setting the information so he wrote Aquí to provide it. The only downside is that it works exclusively on the Mac platform.

Once installed, all you need do is call aqui to set all the appropriate information. I hardly ever travel these days so I wasn’t going to bother but it’s easy to use and can give you your current latitude and longitude as well as your address so I thought, “Why not?”. After I installed and ran it, it gave me my exact address as well as my latitude and longitude. That might sometimes vary a bit depending on the vagaries of GPS but it’s certain to be close.

If you decide to try it out, be sure to take a look at the user manual so see what commands are available. Mostly, though, you’ll just need to run aqui. Also be sure to check out the installation section because you need to install a shortcut. That’s just a matter of clicking on a link in the manual but Aquí won’t work until you do.

A few days ago I announced that I am working on denote-data. The goal is to provide an opt-in, in-memory cache for Denote. It can be used to speed up certain computationally expensive operations. It must be opt-in because there are many users, myself included, who do not need such functionality (I program because the challenge is fun, just how I did with denote-sequence, for example).

I have a final update on this that I posted on denote.git issue 724 and am copying below. Any future changes will appear in the release notes of the next version of Denote. In short: it is happening.

The status update on denote.git

Hello again folks!

I have an update on the denote-data project. The code is in this denote.git branch for now: https://github.com/protesilaos/denote/tree/denote-data

What I am doing:

• Find the computationaly heavy functions.
• Write denote-data variants for them.
• Introduce variables to funcall VAR instead of calling the heavy functions directly.
• Make the denote-data-mode set those variables.

This way we can have any extension do what denote-data does. And this way denote-data can be its own package as well.

1. The first big problem I see now is how to make the caching functions async. I will figure this out by studying list-packages and related.
2. Then I want to study filenotify.el. @mentalisttraceur I have noted that your code is okay for copyright purposes, so I can check it out. Or you can send a PR, if you prefer.

Otherwise, I think this is almost done.

With an opt-in cache we can support other workflows that people have been asking for, such as in-buffer completion.

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

This is an excerpt from the ‘Root Access’ live stream: https://protesilaos.com/codelog/2026-09-27-emacs-live-root-access-show/.

I was making a broader comment there, but it is only available in the full video. Or it may be shared later as another short if @linkarzu gets to it.

One of my favorite Emacs commands is sunrise-sunset (Sunrise/Sunset (GNU Emacs Manual)) to get the day’s times for sunrise and sunset. For it to work right, you must have Emacs pre-configured with location information. This is done by setting three customizable variables:

• calendar-latitude
• calendar-longitude
• calendar-location-name

If you run Emacs on a system that is fixed in location, manually setting the above variables is a one time task. However if you do a fair amount of traveling with Emacs on a laptop, a more programmatic solution might be desired using a location service, ideally an OS-native one. If you’re a macOS user, Aquí (aqui.el) does just that by invoking a Shortcut to query the OS-native location service.

Leveraging Shortcuts gives Emacs access to a high-accuracy fused location update without need to build, install, and configure a separate macOS executable.

Once Aquí is installed, updating the location is done via the aqui command.

1

M-x aqui RET

This will update the above mentioned variables and message the current location in the mini-buffer.

For more information, refer to the Aquí User Guide.

Aquí is now available on MELPA.

As I wrote back in July, although I’ve had Embark installed for some time, I’ve only just begun to really use it. Most of my uses involve following a link (of any type) and acting on a group of files, typically to delete several files at once. Of course, those uses are barely scratching the surface of Embark’s capabilities.

Those capabilities are essentially open ended. By that I mean you can define your own Embark actions. Stefano Rodighiero has a nice example of this. It’s a nice example for two reasons. First, it’s simple and easy to follow even though—the second reason—I don’t know anything about what he’s trying to do. The point is that Rodighiero has an obscure—to me—application that he wants to provide an action for but you don’t need to know the details of the application to follow the action.

This is incredibly powerful. Rodighiero let Embark do the hard work of identifying and parsing the target and merely wrote some simple glue to take that target reference and do something useful with it.

If, like me, you’re just beginning to feel your way around Embark, Rodighiero’s post is a useful read. You almost certainly won’t have a need to copy his action but it’s an excellent go by for your own.

There's a nice long video about Org mode with plenty of tips for beginners. Also, it's the end of the month, so check out the submissions for the Emacs Carnival for September ("Games") and consider volunteering to host the next one!

• Upcoming events (iCal file, Org):
  • Emacs Berlin: Emacs-Berlin Hybrid Meetup https://emacs-berlin.org/ Wed Sep 30 1000 America/Vancouver - 1200 America/Chicago - 1300 America/Toronto - 1700 Etc/UTC - 1900 Europe/Berlin - 2230 Asia/Kolkata – Thu Oct 1 0100 Asia/Singapore
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/316464079/ Thu Oct 1 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/UTC – Fri Oct 2 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • Sacha Chua: Oct 2 - Emacs Chat 31: Pedro A. Aranda Gutierrez (Protesilaos, YouTube)
  • M-x Research: TBA https://m-x-research.github.io/ Fri Oct 2 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/UTC - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • Emacs.si (in person): Emacs.si meetup #10 2026 (v #živo) https://dogodki.kompot.si/events/df5d39f6-4d78-4841-b207-ef2c9e60bd5c Mon Oct 5 1900 CET
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Oct 9 1800 Europe/Paris
• Emacs configuration:
  • Discussion about confirm-kill-emacs (Irreal)
• Emacs Lisp:
  • Charles Choi: Announcing restlib - a utility library for building Emacs REST clients
• Appearance:
  • Tip about changing the default font size (@lispwizard@techhub.social)
  • Per-mode themes (@masukomi@connectified.com)
• Navigation:
  • Marcin Borkowski: forward-paragraph in Magit
  • jadedctrl/bookmark-groups.el: Easily manage separate Emacs bookmark files - Kodujo Ŝɪɴᴏɴᴏᴍᴇ (@jadedctrl@jam.xwx.moe)
  • Some updates on my package ilist-plus (Reddit) extensions to imenu-list
• Hyperbole:
  • Crie botões no Emacs (10:36)
• Dired:
  • C-u M-x dired to pass flags to ls command (@lispwizard@techhub.social)
  • Charles Choi: Binding the SPC key in Dired and IBuffer (Irreal)
• Writing:
  • TIL about Remember mode - built-in persistent-scratch
  • How Emacs does things: flyspell's way of tracking misspelled words (@chris_siebenmann@robot.villas)
• Denote:
  • Protesilaos: Emacs: find a file in the ‘denote-directory’
  • Protesilaos: Emacs: I am experimenting with a Denote cache
• Org Mode:
  • How I Actually Use Org Mode - Emacs Everywhere #3 (01:00:42)
  • Spacemacs | What kind of notes I take? | Productivity (07:04, in French)
  • org for creator - turn your thought from graphs into meaningful posts (13:43)
    • org per creatori - i tuoi pensieri in grafi che creano storie (12:55)
  • James Dyer: Copy Only What You See: Teaching M-w a Prefix Argument (Irreal)
  • org-table-widget 0.3.0: long Org tables now scroll like ordinary text (Reddit)
  • Org tangle and run
  • Supertag V2: I rebuilt a note-taking system, and what I learned (Reddit)
  • Chai 2.1: read, highlight, search and ask your Org book library, with notes you can carry out (Reddit)
  • Org development:
    • Add OTHER_LANGUAGES to the metadata
    • ox-latex: add :alt attribute for images
• Coding:
  • Emacs: clangd and lsp-mode -> diagnostic lag while typing, and an on-demand solution
  • Protesilaos: Emacs: sxhkdrc-mode version 1.3.0
  • Varhammer 1.1.8 "Midnight" - Portable Common Lisp for Windows (Reddit)
• Math:
  • Tip: latex-math-mode minor mode has a menu of symbols (@aethor@fosstodon.org)
• Shells:
  • send-invisible: Handle password prompts in shells or comint when not properly detected (@lispwizard@techhub.social)
• Web:
  • andros/termweb.el: Reformat web pages so they read well in EWW, the Emacs browser (@andros@activity.andros.dev)
  • Einar Mostad: EWW in Emacs 31 would not use browse-url-generic as browse-url-secondary-browser-function
• Mail, news, and chat:
  • GitHub - guibor/teams4e: A mu4e-inspired Microsoft Teams client for Emacs. (Reddit)
• Multimedia:
  • Playing around with OBS, Emacs, and speech commands (01:54)
• LLMs:
  • llm package support for jev / laya-style quick decisions (Reddit)
  • Brainiac v3.0 released (Reddit)
  • Alvaro Ramirez: agent-shell 0.78 updates (Reddit)
  • Fazendo gambiarra com Emacs e Remux (55:31)
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-09-22 / week 38
  • Everyday Emacs 2026-2027 Series - 1 (02:11) - Series of videos in Turkish; live-coding?
• Other:
  • The Emacs Cat: Running Emacs in microVM
• Emacs development:
  • emacs-devel:
    • Detecting and warning about homoglyph attacks
  • Improve directory-files-recursively
  • Fix creation of commit message from ChangeLog (bug#81909)
  • New option vc-dir-simple-unmark-all-files
  • New option vc-quick-select-current-working-tree
  • New command diff-goto-old-source
• New packages:
  • adif: Major mode for viewing and editing ADIF log files (MELPA)
  • aqui: Location update (optimized for macOS) (MELPA)
  • consult-ghostel: Consult integration for ghostel (MELPA)
  • consult-zoxide: Jump to zoxide directories with Consult (MELPA)
  • dharmamitra: Sanskrit/Pāli/Tibetan/Chinese analysis via dharmamitra.org (MELPA)
  • latex-to-svg-for-markdown: Preview Markdown LaTeX math as SVG (MELPA)
  • preview-tab: Temporary file buffers, like VS Code's preview tab (MELPA)

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

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

One of the most common complaints I see from Les Misérables who are stuck in a corporate environment mandating the use of the horrific Outlook for email is that it’s very difficult or impossible to deal with it from within Emacs. For those of us who feel that doing any text oriented task outside of Emacs is an imposition, that’s intolerable.

Patient_Chance_3795 over at the Emacs subreddit has a hint on how to deal with one aspect of the problem: registering an Azure app. Check out his post for a suggestion on how to deal with the issue.

The sad truth is that the main difficulty in dealing with Outlook is not the emails but the other functions such as calendar invites. As usual, Microsoft has made a point of ensuring that you have to use their software if you’re unlucky enough to be find yourself in their ecosphere.

Regardless, every little bit of help in escaping their maw is welcome. If you’d like to at least deal with emails in an Outlook environment, take a look at Patient_Chance_3795’s post.

I recently built Emacs 31 from source to get the newest Emacs on Debian. Most things worked like they used to in Emacs 30 except the few things I knew about from reading up on Emacs 31, but for some strange reason, when browsing with eww inside Emacs, I could no longer hit & and get the site to open in LibreWolf. These are the relevant eww settings in my init.el:

(use-package eww                        ; Web browser
  :config
  (setopt browse-url-browser-function 'eww-browse-url
          browse-url-secondary-browser-function 'browse-url-generic
          browse-url-generic-program "librewolf"
  ; ...

I had a look in the manual to see if there was something new about how browse-url-secondary-browser-function should work, but it seems like it should work exactly like before. I then had a look in the Emacs News (C-h C-n), but it did not say anything about this. The documentation for the relevant variables and functions have not changed either.

Since browse-url-secondary-browser-function no longer accepts 'browse-url-generic, I tried giving it a lambda to start-process "librewolf" instead and that worked perfectly.

(use-package eww                        ; Web browser
  :config
  (setopt browse-url-browser-function 'eww-browse-url
          browse-url-secondary-browser-function (lambda () (start-process "librewolf"))
  ; ...

Another thing that does work is when I do this:

(use-package eww                        ; Web browser
  :config
  (setopt browse-url-browser-function 'eww-browse-url
          browse-url-secondary-browser-function (lambda () (browse-url-generic))
          browse-url-generic-program "librewolf"
  ; ...

When I look up what is bound to & in eww with C-h k, I get eww-browse-with-external-browser.

(defun eww-browse-with-external-browser (&optional url)
  "Browse the current URL with an external browser.
Use `browse-url-secondary-browser-function' if it is an external
browser, otherwise use `browse-url-with-browser-kind' to open an
external browser."
  (interactive nil eww-mode)
  (setq url (or url (plist-get eww-data :url)))
  (if (eq 'external (browse-url--browser-kind
                     browse-url-secondary-browser-function url))
      (let ((browse-url-browser-function browse-url-secondary-browser-function))
        (browse-url url))
    (browse-url-with-browser-kind 'external url)))

When I look into that function's source code, it calls browse-url–browser-kind to determine if the function used for browser-url-secondary-browser-function is an external browser or an internal one and if it is external, uses the function to browse the url by setting browse-url-browser-function temporarily and then use browse-url. If browse-url–browser-kind returns something else, it runs browse-url-with-browser-kind 'external on the url.

When I look at the source for browse-url–browser-kind, it determines if the function used is internal or external by looking at properties set with put for the function. When I looked up browse-url-firefox, after the function definition, there is a line that says (function-put 'browse-url-firefox 'browse-url-browser-kind 'external). If I look up browse-url-generic, I find (function-put 'browse-url-generic 'browse-url-browser-kind 'external) there as well.

When I call browse-url-generic interactively, it works perfectly. When I try to run (browse-url--browser-kind 'browse-url-generic "https://mostad.eu/") it returns external which I also get when running (browse-url--browser-kind browse-url-secondary-browser-function "https://mostad.eu/").

Going back to eww-browse-with-external-browser, when I execute

 (if (eq 'external (browse-url--browser-kind
                     browse-url-secondary-browser-function "https://mostad.eu/"))
      (let ((browse-url-browser-function browse-url-secondary-browser-function))
        (browse-url "https://mostad.eu/"))
    (browse-url-with-browser-kind 'external "https://mostad.eu/"))

it launches mostad.eu in eww, not in librewolf. (This is the part of the function that does the real work, but with url replaced with "https://mostad.eu/" so it works outside the function.) I did a C-x C-e after the if statement and it returned t as expected, so the let should be evaluated. I also tried modifying the else clause to message something if it kicked in and it did not happen.

When I tried the below to see if browse-url-browser-function somehow was something else, then the message buffer showed the even further below output, confirming that it was in fact browse-url-generic.

  (if (eq 'external (browse-url--browser-kind
                     browse-url-secondary-browser-function "https://mostad.eu/"))
      (let ((browse-url-browser-function
             browse-url-secondary-browser-function))
        (message "%s" browse-url-browser-function)
        (browse-url "https://mostad.eu/"))
    (message "neida"))

browse-url-generic
Contacting host: mostad.eu:443
#<buffer  *http mostad.eu:443*>

At this point I was running out of patience and concentration and needed to eat something. Before eating, I remembered when looking through the source code for browse-url-firefox, that it could also open firefox variants if browse-url-firefox-program was set to a firefox downstream, so I tried setting it to "librewolf" and had a go with & in an eww buffer to see if that would work when using & in eww. It did not work. It just reloaded the site I was in in eww.

(use-package eww                        ; Web browser
  :config
  (setopt browse-url-browser-function 'eww-browse-url
          browse-url-secondary-browser-function 'browse-url-firefox
          browse-url-firefox-program "librewolf"
  ; ...

I then reset the setting to browse-url-generic. When trying & in eww, it relaunches the same page in eww. If I set browse-url-secondary-browser-function to any function except the obvious ones like 'browse-url-firefox, 'browse-url-generic etc, for example if I set it to (lambda ()), when I use & in eww, it opens the site in LibreWolf. This seems slightly insane. I went down the rabbit hole and found browse-url-default-browser's source code and it seems to use browse-url-firefox which I previously set up to use librewolf, so maybe that is why this works?

Maybe there is logic saying that browse-url-browser-function and browse-url-secondary-browser-function cannot be the same that stops browse-url from opening the site in librewolf when eww-browse-with-external-browser temporarily sets browse-url-browser-function to browse-url-secondary-browser-function like it does in eww-browse-with-external-browser? I did not see anything like that in the functions I read if I understood them correctly, but I only read some functions and my understanding of Emacs Lisp is still at the beginner level.

I think for now, I will use

(use-package eww                        ; Web browser
  :config
  (setopt browse-url-browser-function 'eww-browse-url
          browse-url-secondary-browser-function (lambda ())
          browse-url-generic-program "librewolf"
  ; ...

which somehow works. I don't know why, but since it works, I'll leave it at that for now.

Is this problem reproducible at all for other people or is it just a problem on my machine? I am on Sway and have set $BROWSER="MOZ_ENABLE_WAYLAND=1 librewolf" in my .bash_profile. I configured Emacs 31 –with-native-compilation=aot –with-cairo –with-harfbuzz –with-gnutls –with-gsettings –with-tree-sitter –with-gif –with-png –with-jpeg –with-rsvg –with-tiff –with-imagemagick –with-pgtk –without-x –with-mailutils

Maybe someone more experienced with Emacs Lisp can look into it further if it is a reproducible problem and clear up why the obvious settings do not work, but other functions works. This could also be user error since I am still learning Emacs Lisp and Emacs in general. I know some things, but there are a lot more things yet for me to learn. Are my settings plain wrong? Have I misunderstood something here?

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

Tonight I will join the livestream that @linkarzu hosts together with Rumen and Ted. We will talk about Emacs. The discussion is open to the audience, so join us to write your questions and just hang out.

I am looking forward to this!

About ‘Root Access’

Root Access is a live conversation with Linkarzu, CEO members, and invited guests about tech, tools, workflows, and what they’re building. Guests can share their projects before we dive into the discussion. Everyone is welcome to watch live and join the chat; the full replay stays public.

Support @linkarzu

• What’s the “Linkarzu CEOs Monthly Hangout” Podcast
• @linkarzu YouTube memembers
• All the ‘Root Access’ episodes

Over at Emacs Dwelling, James Dyer has a nice post on capturing only the visible portion of a folded Org region. When you call kill-ring-save (Meta+w) on a folded region, it will capture everything to the kill ring—even the hidden text. As Dyer says, the folding is just a display hack. All the text is still there.

But sometimes Dyer wants to copy just the visible part. When I first read that, I couldn’t think of how to proceed without a lot of research and probably bit twiddling. That was just me overthinking the problem. It turns out to be pretty easy. The secret is org-copy-visible, which despite its name works outside of Org as well¹.

Once you know that, the rest is easy. You need only call org-copy-visible instead of kill-ring-save. Dyer does that using the shortcut Ctrl+u Meta+w when he wants to copy only the visible part.

Take a look at his post for the code if this sort of thing interests you. You can, of course, simply call org-copy-visible explicitly but if you do it a lot, a shortcut such as Dyer’s make sense.

Isee 724 on the denote.git issue tracker prompted me to start an experiment for an optional, in-memory cache for Denote. The cache can help speed up all sorts of operations.

The goal is to explore what can be done and whether it makes sense to have that as a feature that users can enable, either directly in denote.el or as a separate package.

For the time being, I have what I call denote-data: https://github.com/protesilaos/denote-data. This is not for users and does nothing useful right now. I have not written any documentation on purpose. I am making it available as a proof-of-concept in case there are interested parties who want to contribute to the project.

What I have right now seems solid, though I suspect it will only be useful at scale if the caching is done asynchronously. I plan to to read the manual and check functions such as list-packages to understand how we can do something in the background without blocking Emacs.

If that is done, then the rest is a matter of (i) extending denote-data to cover all cases where files need to be indexed and (ii) plugging it into core Denote functions.

At any rate, this is an experiment. If it proves useful, then I will do what is necessary to make it work with Denote as an opt-in feature.

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.

Emacs Asia-Pacific (APAC) virtual meetup will not be happening this month. See you in the next meetup! Stay updated: https://emacs-apac.gitlab.io/#stay-updated.

A quick look at a Quick Look for Emacs from Charles Choi. MacOS has the notion of a Quick Look to peek at a file without invoking a heavier weight application such as an editor. It’s more than just dumping text onto the screen. It can deal with text, PDFs, HTML, various video files, ODF, Microsoft file types, and many others.

Choi likes the Quick Look functionality but, of course, would like to have it in Emacs too. It’s not clear how to do this in general but it’s trivially easy to do it for Dired and Ibuffer. Choi solves the problem by binding dired-display-file and ibuffer-visit-buffer-other-window-noselect to the Space key. These commands open the file in another window so they’re more than just open the file as usual in Emacs.

If you like the idea of being able to peek at a file without abandoning your current window, take a look at Choi’s post for the details on how to do it from Dired and Ibuffer windows.

Raw link: https://www.youtube.com/watch?v=aEnacESU-DU

[ The event will be recorded. ]

I will join Sacha Chua and Pedro A. Aranda Gutierrez to talk about Emacs. Specifically, Pedro will elaborate on work related to the Org LaTeX exporter. Pedro is doing some interesting work on that front.

Because Denote files are standard files, we do not provide the equivalent of a find-file command to directly open a file in the denote-directory. Though users may still want to have that functionality, which is easy to implement with what core Denote already provides:

(defun my-denote-find-file ()
  "Open a file in the variable `denote-directory'."
  (declare (interactive-only t))
  (interactive)
  (when-let* ((file (denote-file-prompt)))
    (find-file file)))

This can be extended to include commands that only match specific file types or regular expressions in general. For example, here is how we prompt only for files that include .pdf in their name and also modify the minibuffer prompt to indicate what we are doing:

(defun my-denote-find-file-pdf ()
  "Prompt for FILE in the variable `denote-directory' and open it."
  (declare (interactive-only t))
  (interactive)
  (when-let* ((file (denote-file-prompt "\\.pdf" "Prompt for PDF file")))
    (find-file file)))

To take it a step further, we can define a keymap which we may then bind to a prefix key. This way we can access all the “Denote find file” commands we have defined for ourselves:

;; Define the keymap.  Notice the symbol of :prefix, which is used in
;; the `define-key' below.
(defvar-keymap my-denote-find-file-map
  :doc "Commands to find a file in the variable `denote-directory'."
  :prefix 'my-denote-find
  "f" #'my-denote-find-file
  "p" #'my-denote-find-file-pdf)

;; Pick a suitable prefix key.  Here we use C-c f.  So
;; `my-denote-find-file' is this: C-c f f.
(define-key global-map (kbd "C-c f") 'my-denote-find)

Putting it all together:

;; Use this as a template to define as many commands as you need, like
;; with `my-denote-find-file-pdf'.
(defun my-denote-find-file ()
  "Open a file in the variable `denote-directory'."
  (declare (interactive-only t))
  (interactive)
  (when-let* ((file (denote-file-prompt)))
    (find-file file)))

(defun my-denote-find-file-pdf ()
  "Prompt for FILE in the variable `denote-directory' and open it."
  (declare (interactive-only t))
  (interactive)
  (when-let* ((file (denote-file-prompt "\\.pdf" "Find PDF file")))
    (find-file file)))

;; Define the keymap.  Notice the symbol of :prefix, which is used in
;; the `define-key' below.
(defvar-keymap my-denote-find-file-map
  :doc "Commands to find a file in the variable `denote-directory'."
  :prefix 'my-denote-find
  "f" #'my-denote-find-file
  "p" #'my-denote-find-file-pdf)

;; Pick a suitable prefix key.  Here we use C-c f.  So
;; `my-denote-find-file' is this: C-c f f.
(define-key global-map (kbd "C-c f") 'my-denote-find)

Enjoy!

On Oct 2, we'll chat with Pedro about Org Mode, LaTeX exports and font management including alternatives and things you can and can't do depending on your choices. He'll share some tips on fallbacks and emojis, which can help a lot with presentations and documentation. We might also discuss recent patches and realistic objectives.

<2026-10-02 Fri 06:00-07:00> America/Toronto = Fri Oct 2 0600H EDT / 0500H CDT / 0400H MDT / 0300H PDT / 1000H UTC / 1200H CEST / 1300H EEST / 1530H IST / 1800H +08 / 1900H JST

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

A feature of macOS Finder that I enjoy using is Quick Look, where a preview of a selected file can be displayed by pressing the space bar. While “Quick Look” is not really a thing in Emacs (at least not out of the box), we can quasi-emulate this by taking advantage of commands that can open files in another Emacs window, all the while keeping the current Emacs window selected.

In Dired, I’ve bound SPC to the command dired-display-file.

1

(keymap-set dired-mode-map "SPC" #'dired-display-file)

A similar thing can be done for IBuffer:

1

(keymap-set ibuffer-mode-map "SPC" #'ibuffer-visit-buffer-other-window-noselect)

This configuration is definitely a personal preference thing, so YMMV. That said, I’ve found these bindings to be quite useful, so perhaps you may as well.

Over at the Emacs subreddit, Danrobi1 opines that since the advent of use-short-answers, confirm-kill-emacs should be a boolean. His idea is that confirm-kill-emacs should merely specify whether to ask for confirmation or not and let use-short-answers choose the the particular form of the question if one is requested.

00-11 notes that Danrobi1 is misunderstanding the purpose of the confirm-kill-emacs variable: it was never about whether to call yes-or-no-p or y-or-n-p to ask if quitting Emacs is really what you want. What its purpose is and was is to specify a predicate that will decide whether to quit Emacs or not. There’s no reason it even has to communicate with the user. It just has to decide whether to quit or not based on whatever logic is coded into it.

I’ve had it set to y-or-n-p for as long as I can remember and haven’t thought about it in all that time. But 00-11’s response got me thinking. I originally set it to y-or-n-p because I kept inadvertently quitting Emacs by fat fingering some other shortcut and I’ve never looked back but there is one problem.

If I don’t remember to quit Emacs before rebooting my MacBook Pro, the reboot will hang waiting for Emacs to quit. That usually happens when there’s an OS update that I start off when I go to bed expecting to have a new OS in the morning only to find the system still waiting for Emacs to quit.

What if I could detect if my Mac is being rebooted? If I can, I can easily code up a predicate function that quits Emacs if so and calls y-or-n-p if not. The thought just popped into my mind so I haven’t had a chance to research it yet but it seems promising.

Select a region in a folded Org buffer, press M-w, and you get more than you bargained for: the kill ring receives the hidden text as well. Folding is only a display trick - the text is still in the buffer, and kill-ring-save dutifully copies every character between the region boundaries, ellipsis and all. Paste that into an email or a chat and the hidden notes come along for the ride.

The fix, in my config, is a prefix argument: C-u M-w copies only the visible text of the region, leaving everything folded or hidden behind. Plain M-w is unchanged.

I have been a fan of org-copy-visible ever since I discovered it works outside Org - back in 2023 I was using it in dired with dired-hide-details-mode to copy just the filenames. The only friction was having to remember M-x org-copy-visible instead of my muscle-memory M-w. So I taught my existing my/kill-ring-save wrapper a another trick: hand it a prefix argument and it copies only the visible text.

M-w has been remapped to a small wrapper for a while, mainly so that pressing it with no active region copies the current line. The new version forwards the prefix argument into a second branch:

(defun my/kill-ring-save (beg end &optional copy-visible)
  "Save the region to the kill ring.
With a prefix argument, copy only the visible text between BEG
and END, skipping folded or hidden text, like `org-copy-visible'."
  (interactive (if (use-region-p)
                   (list (region-beginning) (region-end) current-prefix-arg)
                 (list (line-beginning-position)
                       (line-beginning-position 2) current-prefix-arg)))
  (if copy-visible
      (org-copy-visible beg end)
    (kill-ring-save beg end)))

(global-set-key [remap kill-ring-save] 'my/kill-ring-save)

[remap kill-ring-save] keeps M-w working everywhere.

So why org-copy-visible?, I could have written my own invisible-text walker, but org-copy-visible already is one and it ships with Emacs!

Recently, I needed to test a full build of my C networking library together with the C build toolchain under NetBSD. Everything is fine on GNU/Linux (Ubuntu) and macOS—I just want to confirm it works on NetBSD as well.

Why NetBSD? NetBSD is an open-source Unix-like operating system famous for its outstanding portability. It runs on an exceptionally wide range of hardware—from modern x86-64/aarch64 servers and desktops to embedded systems, handheld devices, vintage machines (such as VAX and m68k), and even some game consoles (see Platforms supported by NetBSD). Its long-standing motto is “Of course it runs NetBSD”. This makes sense if you want maximum portability.

After all, it’s essentially good old 4.3BSD, which adds a nice touch of nostalgia.

My home data center, as I call it, does not have a dedicated NetBSD machine so I settled on using a virtual machine, or rather, the smolBSD microVM, a minimal NetBSD-based BSD UNIX virtual machine that boots and starts a service in a few milliseconds.

My requirements

My requirements to the microVM are simple.

1. I need to login to the interactive shell (ksh in NetBSD, by default).
2. I need the compiler toolchain and related development files (headers, libraries, build tools such as gcc, make, ld, etc.) because I will compile software inside the microVM.
3. And, of course, I need Emacs for editing, navigating directories, compiling source code, debugging, and many other things that any developer needs.

(Yes, NetBSD comes with vi—not vim!—version 1.81.6-2013-11-20nb4 pre-installed, but… but I just need Emacs.)

Creating the NetBSD microVM from Ubuntu

Installing smolBSD

A detailed description of the smolBSD installation process on Debian-based and macOS systems can be found on the smolBSD GitHub page.

Building a raw microVM image (.img)

To build a raw NetBSD image we will use SMOLerfile, smolBSD’s configuration file for defining a minimal NetBSD-based microVM service. It supports the well-known Dockerfile verbs—like FROM, RUN, CMD etc.—but does not implement the full Dockerfile reference. This is sufficient for our purposes.

My Dockerfile.devsh SMOLerfile that installs and configures Emacs is shown below. I put it in the $NETBSD_ROOT/smolerfiles directory on the host; the NETBSD_ROOT envvar points to the smolBSD installation directory on the host.

# ----------------------------------------------------------
# NetBSD development shell with Emacs included.
# Time-stamp: <Last changed 2026-09-19 16:59:22 by magnolia>
# ----------------------------------------------------------

# Disable: unusual "FROM" naming, multiple RUN don't matter, and non-JSON CMD
# hadolint global ignore=DL3006,DL3025,DL3059

# `base' -- The core system. Contains the essential binaries, shared libraries,
# and utilities required for a minimally functional NetBSD system.
# This set is mandatory.

# `etc' -- System configuration files (primarily under /etc and a few other places).
# Needed for a complete install from scratch;
# provides the default configuration skeleton.

# `comp' -- Compiler/toolchain set. Includes compilers (C/C++),
# header files (/usr/include), static libraries, linker, make,
# and related development tools.

FROM base,etc,comp

# Mandatory -- a name of the service
LABEL smolbsd.service="devsh"

# Shrink the final image to only needed content + extra NNN MB
LABEL smolbsd.minimize=+512
# Extra packages
LABEL smolbsd.addpkgs="pkgin pkg_tarup pkg_install sqlite3 rsync curl"
# Microvm will use a `pty' as console
LABEL smolbsd.use_pty="y"
# 2G disk initially; it will be truncated to minimum + extra NNN MB
LABEL smolbsd.imgsize=2048

ARG HOSTNAME=bsd
ARG USERSHELL=/bin/ksh
ENV USERNAME=magnolia

# Note: INCLUDE is SMOLerfile extension!
# For interactive shell; provided by smolBSD distribution.
INCLUDE smolerfiles/usershell.inc

# ====================================
#               EMACS
# ====================================

# Create ~/.emacs with minimal tuning.
RUN <<EOF
cat > ${HOMEDIR}/.emacs << 'EMACS'
;;; Minimal Emacs config for NetBSD
;; Basic settings
(setq
  column-number-mode t
  ring-bell-function 'ignore
  scroll-step 1
  scroll-conservatively 100000
  scroll-preserve-screen-position 1
  scroll-margin 0
  mouse-wheel-scroll-amount '(1)
  mouse-wheel-progressive-speed nil
  global-visual-line-mode nil
  show-paren-mode t
  tab-always-indent 'indent
  tab-width 4
  tool-bar-mode nil
  truncate-lines nil
  word-wrap t
  make-backup-files nil
  auto-save-default nil
)

;; No line numbers (can be toggled by "C-c l")
(global-display-line-numbers-mode -1)

(setq-default indent-tabs-mode nil)
(global-hl-line-mode 1)
(delete-selection-mode t)
(desktop-save-mode 1)
(savehist-mode 1)

;; No menu
(menu-bar-mode -1)

;; Killing the current Dired buffer upon navigating into a different directory.
(setq dired-kill-when-opening-new-dired-buffer t)

;; Basic C settings
(setq c-default-style "stroustrup")
(setq c-basic-indent 4)
(setq c-basic-offset 4)
(c-set-offset 'innamespace 0)
(c-set-offset 'inextern-lang 0)

;; Some useful keybindings
(define-key global-map (kbd "RET") #'newline-and-indent)
(global-set-key (kbd "M-o") #'other-window)
(global-set-key (kbd "M-a") #'beginning-of-line) ; QEMU intercepts "C-a"
(global-set-key (kbd "M-e") #'end-of-line) ; For consistency
(global-set-key (kbd "C-c l") #'display-line-numbers-mode)
EMACS
chown ${USERNAME} ${HOMEDIR}/.emacs
chmod 600 ${HOMEDIR}/.emacs
EOF

# To use Emacs keys in the shell
RUN echo 'set -o emacs' > /etc/shrc

RUN echo 'alias ll="ls -la"' >> /etc/shrc

# Install Emacs
RUN pkgin up && pkgin -y in emacs-nox11

# Install GNU make; we will use it instead of default `bsdmake'
RUN pkgin -y in gmake

# Login to `ksh', the default shell on NetBSD
CMD login -f -p $USERNAME

To simplify the build process, I’ve created a simple script:

#!/bin/bash

# `smolbsd-build.sh SERVICE'
# ==========================

# NETBSD_ROOT envvar should point to the smolBSD directory on the host.
if [ -z "$NETBSD_ROOT" ]; then
    echo "Error: NETBSD_ROOT envvar not defined."
    exit 2
fi

if [ -z "$1" ]; then
    echo "Usage: smolbsd-build.sh SERVICE"
    exit 1
fi

pushd .
IMAGE="smolerfiles/Dockerfile.$1"
cd $NETBSD_ROOT
echo "Building $IMAGE ..."
./smoler.sh build $IMAGE
popd

Running Emacs in the NetBSD microVM

Here is my script to run the NetBSD microVM:

#!/bin/bash

# `smolbsd-run.sh SERVICE'
# ========================

# NETBSD_ROOT envvar should point to the smolBSD directory on the host.
if [ -z "$NETBSD_ROOT" ]; then
    echo "Error: NETBSD_ROOT envvar not defined."
    exit 2
fi

if [ -z "$1" ]; then
    echo "Usage: smolbsd-run.sh SERVICE"
    exit 1
fi

pushd .
cd $NETBSD_ROOT
# 1) -f CONFIG      VM configuration file; it's created automatically during the build stage.
# 2) -P             use PTY terminal
# 3) -n 2           enable stopping VM from ksh (as `su'): . /etc/include/shutdown
# 4) -w PATH        mount host's PATH to guest's /mnt/
./startnb.sh -f "etc/$1.conf" -P -n 2 -w ${HOME}/workspace/devel
popd

Now we can run the devsh microVM (bsd) on the host (foxtrot):

As you can see, the NetBSD kernel starts in 26 ms on my old Dell Latitude 7400 laptop. The entire VM initially occupies 180 MB of host memory. Not a bad result.

And then we can run Emacs:

Happy emacsing in VM!

— The Emacs Cat.

This is a major mode for editing sxhkdrc files. SXHKD is the Simple X Hot Key Daemon which is commonly used in minimalist desktop sessions on Xorg (I use it with bspwm, herbstluftwm, and i3wm). The sxhkdrc file configures key chords, binding them to commands. For the technicalities, read the man page sxhkd(1).

• Package name (GNU ELPA): sxhkdrc-mode
• Git repositories:
  • GitHub: https://github.com/protesilaos/sxhkdrc-mode
  • GitLab: https://gitlab.com/protesilaos/sxhkdrc-mode
• Backronym: Such Xenotropic Hot Keys Demonstrate Robustness and Configurability … mode.

1.3.0 on 2026-09-23

This version makes quality-of-life refinements to an already stable package.

Fontification of key chord chains

Key chord chains are written with the semicolon (;) or colon (:) characters. The former refers to one-shot operations while the latter is for continuous ones that exit only with Escape.

The corresponding faces are sxhkdrc-mode-chain-one-off-separator and sxhkdrc-mode-chain-continuous-separator.

Support for all command prefixes

The previous version only covered the ; in front of a command. The prefixes @ and ~ are now covered as well. They are all using teh face sxhkdrc-mode-command-prefix, which supersedes the deprecated sxhkdrc-mode-command-async.

Continuation lines in commands are highlighted as well

This concerns the backslash character (\) at the end of a line. The applicable face is sxhkdrc-mode-continuation-line.

All modifiers are covered

The updated manpage of SXHKD, sxhkd(1), mentions all the modifiers that it supports. I have extended support for all of them in the order they appear in the manual.

Another month, another agent-shell update. If you missed the last post, have a look at the 0.73 update.

As usual, this post showcases highlights, but please check out the full list of changes if you're after the nitty-gritty.

What's agent-shell?

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

New supported agents

Two agents join the family, available as usual via M-x agent-shell, or explicitly as follows:

• Antigravity (Google), #795 by @tychoish. Start it with M-x agent-shell-start-antigravity-agent.
• Qoder CLI, #831 by @unship. Start it with M-x agent-shell-start-qoder-agent.

Prompt any time

Likely the most impactful feature in the release. It's highly discoverable and plenty useful, so I'm expecting a fair amount of uptake.

A typical shell experience offers a prompt. Users type and submit their commands and wait for the command to finish before the shell prompt is offered again.

Deriving from comint-mode, agent-shell was no different. That is, until now.

As of v0.78, agent-shell offers a writeable prompt at the end of the buffer at all times. Submit, and the prompt comes right back while the agent is busy handling the turn. Type and submit again and agent-shell will automatically queue your request if necessary.

While queueing itself isn't a new feature, the shell prompt queueing route offers a freebie in terms of cognitive load. Submit prompts as you used to (via RET binding), and let agent-shell decide whether to handle now or queue for later.

The persistent prompt is enabled by default via agent-shell-persistent-prompt-enabled. If this isn't your cup of tea, it can be easily disabled with:

(setopt agent-shell-persistent-prompt-enabled nil)

The viewport's compose buffer is there either way, and submitting from it mid-turn routes through exactly the same logic.

Steering a running turn

As of this release, agent-shell can also steer turns (provided the agent supports the _session/steering ACP extension). Steering enables you to course correct in-flight prompts without cancelling or waiting for the prompt processing to finish. As of today, I'm aware of Claude and Codex handling ACP steering, but please reach out if you know of others.

Steering an in-flight turn via M-x agent-shell-prompt-steer offers a similar experience to the existing M-x agent-shell-prompt-queue. That is, prompting the user for text in the minibuffer. Having said that, we now have a new and shiny persistent prompt, and as we now know, the RET binding automatically queues if needed. From the same prompt you can now also steer by submitting via the M-RET binding.

Huge thanks to @OSadovy, who took on the legwork for steering in #777.

Configurable RET

With RET and M-RET respectively queueing and steering as needed, the default behaviour is configurable via agent-shell-busy-submit-default-function (queues by default) while the M-RET (or C-u RET) route uses agent-shell-busy-submit-override-function (steers by default). Both customizations accept a function, so swapping would offer RET steering and M-RET queueing with something like:

(setopt agent-shell-busy-submit-default-function
        #'agent-shell-busy-submit-steer)
(setopt agent-shell-busy-submit-override-function
        #'agent-shell-busy-submit-queue)

Both apply wherever a prompt is submitted mid-turn, the shell prompt and the viewport's compose buffer alike. As emacsers, we want all sorts of customizations, so custom functions can be used too, if you'd like something a little different from what's offered.

Drag and drop

While we could already C-y paste screenshots from the clipboard, we can now drag and drop files from external file managers onto either shell or viewport buffers. Images get a preview, anything else is attached as an @path link.

Thank you @dustinfarris for #825. While on topic, @dustinfarris fixed file mentions carrying whitespace in paths (#824).

macOS freebie

After all this time, I had no idea the temporary thumbnail generated by macOS's screenshot utility is draggable, and so you can now drop it straight into your agent-shell session.

Thanks to @dustinfarris for the tip!

Displaying cost

If you'd like to keep an eye on token cost, headers can now show the session's cumulative cost, right after the context usage indicator.

Currently off by default, so opt in with:

(setopt agent-shell-show-cost-indicator t)

Keep in mind cost is displayed for agents reporting cost via ACP. Thank you @mrcnski for #834.

Searching folded buffers

agent-shell folds lots away by default (tool calls, thinking, groups), requiring additional help if we want closer isearch integration. Thanks to @mrcnski's contribution in #832, folded fragments now respect search-invisible.

Searching also folds back what it expanded once you're done, groups included. Also thanks to @Gleek for #827: expanding a fragment no longer clobbers isearch's match data.

Slash command recognition

Slash command completion is now offered more idiomatically across all three surfaces (shell prompt, viewport compose buffer, minibuffer): it only kicks in when whitespace alone precedes the /. Thank you @izeigerman for #810.

File completion after @ is unchanged.

Copying last output

We now have M-x agent-shell-copy-last-output, which grabs the most recent output regardless of point location, so you can pull the latest response from anywhere in buffer.

Link improvements

Links got a handful of fixes/improvements worth mentioning:

• File references inside code spans are now linked (#781, #782, thanks @OSadovy).
• Links inside tables are now actionable.
• Links are now more robust while streaming.
• Links to local directories now open in dired.
• The cursor-sensor hint is no longer misaligned on links.

Viewport paging with prefix args

C-u N on next/previous page now moves N interactions instead of one, and a negative prefix pages the other way. Moving forward past the newest interaction restores a parked compose snapshot, so C-u N does what pressing the key N times does, rather than stopping short of your draft. Thank you @liaowang11 for #813.

Table faces

Following on from last month's table work, plain data rows now get a face of their own, and every table face inherits from one base face. If you'd like to restyle tables wholesale, you now have a single place to do it. Thank you @mrcnski for #822.

Session handling

• Session lists are now paginated under the hood, requesting available sessions until agents run out (#809 by @KarimAziev). If you'd rather cap your session list, agent-shell-session-list-page-limit takes a positive integer.
• Restarting shells now preserves window arrangement.

Public functions

agent-shell-session-id

agent-shell-session-id returns the current ACP session ID. On that note, there's also M-x agent-shell-copy-session-id for when you just want it in your kill ring.

OpenCode config options

agent-shell-opencode-default-model-variant was a bit narrow, so it's been replaced by agent-shell-opencode-default-config-options, an alist of whatever OpenCode advertises under "Available config options" when starting a new shell:

(setopt agent-shell-opencode-default-config-options
        '(("model" . "anthropic/claude-opus-4-5")
          ("effort" . "high")
          ("mode" . "plan")))

Options are applied in the order listed, and order matters. Thank you @nhojb for #739.

New third-party packages

Four more joining the lot:

• agent-shell-org-config: Keep agent-shell agent, project, and skill definitions in org-roam.
• agent-shell-permission-transient: A compact Transient interface for responding to queued permission requests.
• agent-shell-queue: A flexible prompt/shell queue for agent-shell sessions.
• agent-shell-queue-transient: A Transient interface for the prompt queue in agent-shell.

Markdown overlay renderer now retired

With the new renderer offering a richer Markdown experience for some time now, the deprecated markdown-overlays renderer is gone.

Housekeeping

If you peeked at the commit logs for the period, you'll see it's been another busy month. Since the last post, 153 commits shipped, 32 issues have been closed and 25 pull requests merged. As of this writing, the backlog sits at 16 open issues and 6 open PRs (versus 11 and 5 last time around).

Zooming out a little, here's how the backlog has tracked since March:

Side note: this chart was generated using the /github-activity skill shared in my emacs-skills repo.

From the graph, it's evident when I became a father, but you can also see I managed to bring things back down, hovering at a fairly stable level since.

All of this requires daily attention 👉 hint hint 👈

agent-shell needs your support

These days (especially at the workplace), vendor-neutral tooling matters more than ever, and there are a couple of ways to help keep agent-shell going. Some cost money, others just a click. All are appreciated ;)

Sponsorships for agent-shell longevity

agent-shell is built and maintained by me, an indie dev, while the tools it often competes with at the workplace have well-funded teams behind them. Time spent on agent-shell is time away from other work that pays the bills, so if it's useful to you, please consider sponsoring the project. And if your employer benefits from your agent-shell use, nudge them to chip in too, they can typically contribute at a scale individuals can't.

GitHub stars for exposure

GitHub stars help with exposure, attracting new users and potential sponsors. Starring agent-shell costs nothing and can potentially help bring in more funding, so if you don't mind a couple of clicks, the project can really use another GitHub star.

Pull requests

Thank you to all contributors for these improvements!

• #739: Add opencode model variant customization (@nhojb)
• #772: Ask about killing the shell only when that is what was asked for (@OSadovy)
• #777: Steer prompts into the running turn instead of queueing them (@OSadovy)
• #794: Mark restored prompts with comint-highlight-prompt (@OSadovy)
• #795: Add agent-shell-antigravity (@tychoish)
• #796: Add agent-shell-queue link (@tychoish)
• #801: Strip copies in the substring filter, not via yank-handler (@OSadovy)
• #802: Fix chat prompt indentation (@nhojb)
• #804: Stop the live prompt flickering on every keystroke (@alberti42)
• #808: Fix viewport prompt font-lock face precedence (@liaowang11)
• #809: Handle ACP session/list pagination (@KarimAziev)
• #810: Slash command completion at prompt start (@izeigerman)
• #812: Display Pi terminal output in agent-shell (@timfel)
• #813: Add prefix-arg page jumps to viewport paging (@liaowang11)
• #821: Check dependencies against the Package-Requires floors (@alberti42)
• #822: Give plain table data rows a face (@mrcnski)
• #824: Quote file mentions whose path holds whitespace (@dustinfarris)
• #825: Attach files dropped on a shell or viewport buffer (@dustinfarris)
• #827: Preserve isearch match data when expanding fragments (@Gleek)
• #828: Add agent-shell-org-config to Related projects (@lllShamanlll)
• #830: Fix provider icon downloads via LobeHub CDN (@tjohnman)
• #831: Add Qoder CLI ACP backend (@unship)
• #832: Respect search-invisible (@mrcnski)
• #834: Show session cost in the header (@mrcnski)
• #837: Add agent-shell-queue-transient link to README (@mrcnski)

Make it sustainable, sponsor the agent-shell

Liking agent-shell? Would like to see it evolve? Consider sponsoring the effort.

In keeping with this blog’s recent interest in building REST clients in Emacs Lisp (Elisp), here’s a utility library I’ve assembled that covers some common tasks in doing so. I’ve named this package restlib (https://github.com/kickingvegas/restlib) and it is now available on MELPA. restlib is organized into the following three sections:

• Network (HTTP) requests
• URL components
• JSON processing

Further reading about these sections can be found in the restlib API Reference.

To get an idea of what you can do with restlib, explore the source code for a lightweight weather lookup client using https://wttr.in called wttr.el.

Anecdotally, I’ve already created a number of internal REST clients using restlib, some of which I plan to publish on MELPA in the near future. As restlib is early in its development, there is always room for improvement. If you have any suggestions for improving restlib, feel free to submit an issue.

I put the new typewriter mode in the Fun category, but people might actually find the constraints useful for focused writing.

• Upcoming events (iCal file, Org):
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Sep 26 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/UTC - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
  • Emacs Berlin: Emacs-Berlin Hybrid Meetup https://emacs-berlin.org/ Wed Sep 30 1000 America/Vancouver - 1200 America/Chicago - 1300 America/Toronto - 1700 Etc/UTC - 1900 Europe/Berlin - 2230 Asia/Kolkata – Thu Oct 1 0100 Asia/Singapore
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/316464079/ Thu Oct 1 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/UTC – Fri Oct 2 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Oct 2 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/UTC - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
• Emacs configuration:
  • Repeat mode finally made Emacs navigation click
  • J.e.r.e.m.y B.r.y.a.n.t: New from Emacs 31.1 - Upgrade packages without breaking other Emacsen
• Emacs Lisp:
  • Raymond Zeitler: A Niftier Way To ASCIIfy An Emacs Buffer - replace-char-fold
  • Livecoding for emacs: supersonic.el (08:06)
• Appearance:
  • Protesilaos: Emacs: spacious-padding version 0.9.0
• Navigation:
  • Protesilaos: Emacs: beframe version 1.6.0
• Dired:
  • Protesilaos: Emacs: dired-preview version 0.7.0
• Writing:
  • markup2html: aesthetic renderer of markdown and org-mode documents (Reddit)
• Org Mode:
  • Org Mode requests: [RFC] Org markup inside comments (was: [Bug] Confusing appearance of bracket link in comment)
  • Ashish Panigrahi: An upgraded workflow on reviewing finished tasks with org-agenda
  • Org Mode, Marked, and Workflows
  • I Migrated My Obsidian Vault to Org Mode - Emacs Everywhere #2 (01:12:35)
  • Org Roam Dashboard (10:01)
  • Org development:
    • org-id: Standardize UUIDs to lowercase and use built-in uuid.el
• Completion:
  • Bumbling my way through the Consult docs to build an async completer (Reddit)
• Coding:
  • TIL magit wraps around smerge so you can discard one side of a hunk with an unresolved conflict (@slackline)
  • Python settings for Flycheck in GNU Emacs (as of September 2026) (@chris_siebenmann@robot.villas)
  • Pinned Tree-sitter grammars for Emacs treesit (emacs-treesit-grammars flake) (Reddit)
• Shells:
  • Why Your Emacs Terminal is Slow and How to Fix It (vterm, eat, ghostel, term, and ansi-term) (Reddit, Irreal)
• Mail, news, and chat:
  • Microsoft outlook OAuth authentication with mu4e (Reddit) - updated to use Thunderbird client ID
  • Using an existing Microsoft 365 MCP login to get Outlook mail into mu4e
  • andros/presence.el: See when your friends are online, away or offline, and send and read simple messages, right from Emacs
• Doom Emacs:
  • ¿Por qué Doom Emacs es el secreto de los expertos? (22:25)
• Multimedia:
  • Images with Emacs (19:00)
• Fun:
  • New package: Typewriter (Reddit)
• LLMs:
  • envoy: hand an org heading or email from Emacs to a coding harness in tmux (Reddit)
  • gptel: Emacs y la IA
  • moe-microscope/docs/literate/moe-microscope.org at main · sw-ml-study/moe-microscope · GitHub
  • AI Tools #7: A Coding Agent Small Enough to Understand | Software Wrighter Lab Blog
• Other:
  • Tip: C-u C-y yanks but leaves the cursor at the beginning of the string (@lispwizard@techhub.social)
  • Create beautiful diagrams in Emacs using d2 (11:08, code, Reddit, Irreal) - also Org support
  • How to Prevent Emacs from Freezing on Files files with Very Long Lines (e.g, minified JavaScript, compiled CSS, SQL dumps, large JSON files…) (Reddit, Irreal)
• Emacs development:
  • ; * etc/NEWS: Announce underline styles support on Windows Terminal.
  • Add TTY support for overline (Bug#80208)
  • use-package-ensure.el: Don't install during compilation (bug#81710)
  • ; Some followup Tramp changes of sync with 2.9.0
  • Update to Unicode 18.0 (bug#81880)
  • Document tramp-tolerate-tilde
  • * lisp/vc/diff.el (diff-switches): Include "-r".
  • Populate 'pcpu' and 'pmem' attributes on Darwin
• New packages:
  • amber-mode: A major mode for the Amber programming language (MELPA)
  • git-modeline: Show the git status of the current file in the modeline (MELPA)
  • latex-to-svg-for-org: Preview Org LaTeX math as SVG (MELPA)
  • magit-standup: Collect recent git commits for standup notes (MELPA)
  • nightpanel-theme: Saab instrument cluster colorscheme (MELPA)
  • org-roam-stats: Personal Knowledge Management Dashboard (MELPA)
  • remoto: Browse GitHub repos without cloning (MELPA)
  • restlib: Utility library for building REST clients (MELPA)
  • testcover-audit: Quantitative coverage statistics for testcover.el (MELPA)
  • typewriter: Turn Emacs into a text adder (GNU ELPA)

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

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

I’m still getting used to the Glove80. Writing text is doable but still painfully slow.

I mentioned I use tangent, which integrates the Glove80 layout. One thing it doesn’t have though is a practice layer for Emacs, with Emacs key chords like C-c C-z, for example.

So I called Claude for help.

I’m on the third version of this mod, adding the command names from Emacs, so that I know what the commands I’m retraining my fingers on are — because my fingers remembered these commands (and thus are now clueless), and now I need to commit them to memory again through my eyes. This here is the first post written fully with the Glove80. I’m getting there.

You know how people have little “eternal quests” like searching for the perfect wallet, or the perfect t-shirt, or whatever? One of mine is the perfect app for making diagrams in Emacs and Org-mode. My go to solution is Graphviz, which I always seem to end up using. It’s powerful and not too hard to use but I don’t use it enough to internalize its syntax. So I’m always on the lookout for a better way. I’ve tried a bunch of them but I always go back to Graphviz.

I just saw this video by Skybert Hacks (Torstein Krause Johansen) about using D2 for this very problem. Its syntax seems reminiscent of Graphviz but a little simpler and easier to remember. It integrates beautifully with Org-mode so it’s just perfect for writing reports, papers, notes, or blog posts.

D2 produces nice diagrams—see the Skybert Hacks’ video for some examples—and is worth trying out. I’m going to do just that the next time I need to embed some videos in one of my documents. I just saw the video so I’m not familiar with the ins and outs of the app yet but it seems worth a little effort to learn. Once I try it out, I’ll report back and let you know how it worked out.

This package provides a global minor mode to increase the spacing/padding of Emacs windows and frames. The idea is to make editing and reading feel more comfortable. Enable the mode with M-x spacious-padding-mode. Adjust the exact spacing values by modifying the user option spacious-padding-widths.

• Package name (GNU ELPA): spacious-padding
• Official manual: https://protesilaos.com/emacs/spacious-padding
• Change log: https://protesilaos.com/emacs/spacious-padding
• Git repositories:
  • GitHub: https://github.com/protesilaos/spacious-padding
  • GitLab: https://gitlab.com/protesilaos/spacious-padding
• Sample images:
  • https://protesilaos.com/codelog/2023-06-03-emacs-spacious-padding/
  • https://protesilaos.com/codelog/2023-11-15-spacious-padding-extra-ui-dev/
• Backronyms: Space Perception Adjusted Consistently Impacts Overall Usability State … padding; Spacious … Precise Adjustments to Desktop Divider Internals Neatly Generated.

Version 0.9.0 on 2026-09-20

This is a small version that addresses a minor inconvenience with the Emacs daemon process reporting an unspecified-bg under certain circumstances. The workaround I defined ensures that we always use a known colour value.

Other than that, the margin face, which was introduced in Emacs version 31, is also handled by spacious-padding-mode.

My friend Watts Martin is back with some additional thoughts on Markdown. A year ago he wrote a post complaining about the ankle biters who claim you can’t do serious writing with Markdown. I responded positively to his post and noted that even though I’m all in on Org mode and use it for virtually everything I write—even iMessages through the wonderful emacs-everywhere—it’s not really a good solution unless you’re using Emacs (although some people like Karl Voit disagree).

These days, Martin is an Emacs user and does use Org mode a lot but he still prefers to write his documentation and prose in Markdown. The reason for that is partly that he’s used to it but also because he has tools to work with it and—at least in the case of documentation—has to worry about collaboration.

It’s hard to disagree with anything he says although, again, Karl Voit strongly disagrees with the assertion that neither is better than the other, even when considered solely as markup languages. Even Martin appears to agree that Org is the better tool when you can consider its normal environment.

As for the original question that got all this started, of course Markdown or Org mode can be used for serious writing as plenty of writers demonstrate everyday. It’s only the ankle biters—probably the same ones who claim em-dashes are used only by AIs—who say otherwise.

In my last blogpost, I showcased how I review tasks finished over the last seven days. It implicitly assumes that I attend every group meeting^[1] and that the group meeting happens during the same time every week^[2].

In a more practical sense, it would be nice to generalize this workflow. I would like to specify a date, since when completed tasks would be displayed until the current day. This way I would be able to review my finished agenda items since a particular day in the past. This date would typically be when the group meeting last occured, but we are not strictly bound to it.

Implementation in emacs lisp

We write an elisp snippet similar to the one in the previous blogpost.

(defvar pani/last-group-meeting-date nil)

(setq org-agenda-custom-commands
      '(("v" "Finished tasks since last group meeting"
          tags
          (format "CLOSED>=\"<%s>\""
                  (setq pani/last-group-meeting-date
                        (org-read-date nil nil nil "Last group meeting: ")))
          ((org-agenda-overriding-header
            (format "Finished tasks since %s" pani/last-group-meeting-date))
           (org-agenda-archives-mode t)
           (org-agenda-tag-filter-preset '("-emacs" "-personal" "-email" "-misc"))
           (org-agenda-prefix-format '((tags . " ")))
           (org-agenda-remove-tags nil)))))

Most of the config options are similar so I won't be going over in detail. Let's instead point out the differences.

• Since we would like emacs to prompt for a date, we use the org-read-date function. We also replace CLOSED>=\"<-7d>\" with CLOSED>=\"<%s>\" with %s being a placeholder for the specified date. For more details on org-read-date, read the official documentation.
• The org-agenda-overriding-header is slightly modified to display the text "Finished tasks since 2026-09-16" if 16th September is selected during the date prompt.
• We define a variable pani/last-group-meeting-date which stores the value of the date specified. Hence, before the custom org-agenda view is called, it stores nothing i.e. NIL.

To invoke this view, we simply run M-x org-agenda and hit v to get into the view.

Invoking custom org-agenda views (slightly) faster

Just like in the previous workflow, we write another function to invoke this custom org-agenda view and bind it to C-c v to invoke it faster.

  (defun pani/done-items-since-meeting-org-agenda ()
    "Prompt for the date of the last group meeting and show completed tasks since then.
It displays every DONE item closed from the chosen day upto today."
    (interactive)
    (org-agenda nil "v"))

When invoking the view, we are prompted for a date with a pop-up calendar. We select a particular date in the past; Typing "-wed" to select last Wednesday, we are instantly greeted with the following view:

With this, we can review tasks not just from the last seven days, but basically from any day in the past!

James Cherti has another excellent post in his series exploring Emacs optimizations. This one discusses improving Emacs performance on files with long lines. As those of you who have to deal with long lines know, Emacs doesn’t handle them very well and is prone to freeze while trying to render them.

One good solution for this is Phil Sainty’s excellent so-long package. The idea is that so-long detects when when Emacs is dealing with long lines and turns off certain computationally expensive features such as syntax highlighting and font-lock mode. This is a big help in speeding up Emacs’ processing of long lines but it also disables some useful features.

Cherti’s idea to to provide more granular control. For example, while syntax highlight does impose a processing penalty, it also makes code easier to read for many people. Cherti shows how to get so-long to not disable syntax highlighting.

Cherti examines several other features that can be disabled, or not, by so-long and discusses the pros and cons of doing so. He shows you how, in effect, to fine tune so-long to achieve your desired balance between performance and utility.

I really like this story because it’s a perfect example of how Emacs makes it easy to solve problems. First, there was the problem of Emacs freezing when dealing with long lines. Phil Sainty, who is not a member of the Emacs development team, helped ameliorate that problem with a third party package. Then James Cherti noticed that in certain situations you might want a less drastic effect than the default so-long action and showed how to achieve that. Even Cherti’s suggestions can be customized to suit the individual user. It’s Emacs at its best.

This is a simple package to automatically preview in a window the file at point in Dired buffers. Preview windows are closed when they are no longer relevant, while preview buffers are killed if they have not been used for other purposes beside previewing. The package provides several customisation options to control its behaviour.

• Package name (GNU ELPA): dired-preview
• Official manual: https://protesilaos.com/emacs/dired-preview
• Git repositories:
  • GitHub: https://github.com/protesilaos/dired-preview
  • GitLab: https://gitlab.com/protesilaos/dired-preview
• Backronym: Directories Invariably Render Everything Decently … preview; dired … PDFs Require Extra Viewing Instructions for Emacs to Work.

Below are the release notes

Version 0.7.0 on 2026-09-18

This version introduces a few refinements to an already stable code base.

The dired-preview-ignored-extensions-regexp becomes dired-preview-ignored-extensions

This change reflects the broadened flexibility of the user option. Before, it used to accept either a nil value or a regular expression (i.e. a single string). In addition to these, it can now accept a list of strings, each of which represents a file type extension.

The default value is basically this:

;; Illustration of the new value
(setq dired-preview-ignored-extensions
      '("mkv" "webm" "mp4"
        "mp3" "ogg" "m4a" "flac" "wav"
        "gz" "zst" "tar" "xz" "rar" "zip" "iso"
        "epub" "pdf"
        ".DS_Store"))

And here is how it used to be:

;; Illustration of the old variable and its value
(setq dired-preview-ignored-extensions-regexp
      (concat "\\."
              "\\(mkv\\|webm\\|mp4\\|mp3\\|ogg\\|m4a\\|flac\\|wav"
              "\\|gz\\|zst\\|tar\\|xz\\|rar\\|zip"
              "\\|iso\\|epub\\|pdf\\)\\'"))

Again, the old single regexp is supported, though I think the list is easier to write.

New dired-preview-hook and the dired-preview-with-window macro

The hook is run when a preview is displayed. Functions that need to act with the preview window as current can rely on the macro dired-preview-with-window. Look at the code to get an idea of how the macro is used.

Thanks to dasoju for requesting the hook in issue 32: https://github.com/protesilaos/dired-preview/issues/32.

The dired-preview-find-file and dired-preview-open-dwim are robust

They should always find the underlying file and do the right thing with it. Basically, they should always work if there is a preview window.

The dired-preview-image-extensions-regexp is obsolete

This was a user option since the early days of the package. I left it there by mistake. The manual was not mentioning it but it is possible that users have configured it.

Its new name is dired-preview-image-extensions and it is just a variable (not a “user option”), meaning that users should configure it only if they know what they are doing.

The preview trigger is more robust

It should now work reliably and do what is expected of the preview. I fixed this in response to issue 33 by dasoju: https://github.com/protesilaos/dired-preview/issues/33.

The preview state is handled properly

The preview window is closed when it ought to without affecting the rest of the layout. Unexpected values are also handled gracefully. With regard to the latter, thanks to abdulnafe-t for reporting a bug which helped me notice this problem. The report is part of issue 34: https://github.com/protesilaos/dired-preview/issues/34.

The original value of dired-dwim-target is handled correctly

The dired-dwim-target is changed by the preview so that relevant Dired operations are not affected by the preview window. When we need to restore that variable to its original value, we now do it without hardcoding a preference.

Thanks to qhga for bringing this matter to my attention in issue 36: https://github.com/protesilaos/dired-preview/issues/36.