For more than a decade the Clojure REPL most people saw in a terminal was REPLy, the one behind lein repl. It served us well, but it’s showing its age, and I kept wishing for a terminal REPL that felt like CIDER, without the Emacs part. So I finally built one. neorepl 0.1 is out today!

Why another REPL?

There’s no shortage of Clojure REPLs, so it’s fair to ask. Here’s what I was after:

• nREPL all the way down. neorepl only speaks nREPL, so it works with anything that runs an nREPL server: Clojure, babashka, shadow-cljs, Basilisp, ClojureCLR and so on. The smarts live on the server. When cider-nrepl is there neorepl uses it, the same way CIDER does, and when it isn’t it falls back to nREPL’s built-in ops, and then to evaluating a bit of code.
• A REPL that’s pleasant to use: a proper line editor, highlighting, completion, arglists as you type, pretty printing, history per project and a Ctrl-C that actually interrupts the evaluation.
• A CLI that’s just as good for scripts and coding agents. Every lookup the REPL can do is also a command, with structured output and exit codes that mean something.
• Something small and modern. Clojure 1.10+, nREPL and JLine 4 are the only dependencies, and the same code runs on the JVM and on babashka. The whole thing is about 3,300 lines right now, and I’d like to keep it that way.

rebel-readline and bb repl --connect are both great, and I borrowed from them freely, but neither tries to be an nREPL-first tool with CIDER’s tooling, jack-in and a CLI for agents. That combination is the whole point of neorepl.

For humans

Here’s the REPL in action:

A few things worth pointing out:

• Enter only submits the input once its forms are complete, so pasting a whole function just works.
• TAB completes, with the candidates’ types next to them, and the arglist of the function you’re calling shows up after the cursor.
• Values get pretty printed on the server and highlighted on the client.
• Commands start with a comma, the CIDER way: ,doc, ,source, ,apropos, ,macroexpand, ,pst, ,reload, ,edit (which opens a definition in your $EDITOR) and ,help for the rest. The Clojure reader sees a comma as whitespace, so they can’t clash with real code.
• Ctrl-C interrupts what’s running, and code that reads *in* gets its input, something REPLy never quite got right.

Without a server to connect to, neorepl starts one for the project, the way CIDER’s jack-in does, with cider-nrepl on the classpath, and stops it when you exit. It knows Leiningen, the Clojure CLI, babashka and shadow-cljs projects.

ClojureScript works too. Start a ClojureScript REPL in the session (through shadow-cljs or piggieback, which jack-in adds for you) and neorepl follows along: evaluation, completion, docs and the rest switch to ClojureScript, and :cljs/quit takes you back.

For agents

Coding agents are surprisingly good at Clojure, as long as they have a REPL to talk to. Most of them drive CLIs much better than anything else, so neorepl has a CLI that’s meant to be driven:

• neorepl eval evaluates code on the project’s server. Calls share a session, so *ns*, *1 and *e carry over from one call to the next, and --session keeps separate lines of work apart.
• --format json (or edn) gives you the values, the output and the namespace as data.
• --timeout interrupts the evaluation before giving up, so an infinite loop doesn’t take the server down with it, and --max-output keeps a stray (range) from eating the agent’s context.
• neorepl check finds unbalanced parens, brackets and braces without a server. That’s the most common way for an agent (or a human) to break a Clojure file.
• neorepl doc, source, apropos, complete, where, macroexpand and reload do what the REPL’s commands do.
• neorepl server starts a server that stays up, for editors, agents and neorepl eval to share.

The exit codes are boring on purpose: 0 when all went well, 1 for an evaluation error, 3 when there’s no server to talk to and 124 for a timeout (like timeout(1)).

Playing nicely with nREPL

A new client is also a new way to break servers, or to be broken by them, and the nREPL world has quite a few servers these days. Fortunately I’ve been working on proof, a compatibility suite for nREPL, which made neorepl a good test subject.

proof checks both sides of the conversation. proof proxy sits between a client and a server and grades everything the client sends: every request has an id, need-input gets answered with stdin in the right session, and so on. proof serve is a small nREPL server that can behave like other servers in very specific ways - sending only the last value of the code like Basilisp and jank, dropping stderr, having no interrupt op, splitting output into one message per character, and so on. I ran neorepl’s REPL and CLI through both, against nREPL, babashka, Basilisp and jank, and through every quirk proof serve knows about.

neorepl came out of it in decent shape, but not unscathed:

• Code read from stdin (neorepl eval -) that then read *in* itself crashed neorepl and left the evaluation waiting on the server for input that was never coming.
• neorepl’s errors could leave the shell’s prompt dangling at the end of a line with servers that don’t end their error reports with a newline (hello, jank!).
• neorepl eval exited with 1 when it lost the server, which is the status for code that failed.

All of those are fixed in 0.1. It also turned up a couple of things that are nREPL’s fault rather than neorepl’s: need-input and the end of an interrupted evaluation can go to the wrong connection when a session is used from more than one. Those will be fixed in nREPL itself.

It works the other way around too. proof now checks servers with the exact requests neorepl sends while starting its REPL and evaluating code, next to the ones CIDER, Calva, Conjure, vim-fireplace and REPLy send, so a server that breaks neorepl finds out from proof, not from a bug report. nREPL, babashka, Basilisp and jank all pass those checks today.

Making the neighbours better

Building neorepl turned up a few problems elsewhere, which is one of my favourite side effects of writing a new client. piggieback used to evaluate only the first form you sent it and silently drop the rest, and it loaded the ClojureScript compiler at startup even when nobody asked for a ClojureScript REPL, which added almost half a second to the startup of every server with ClojureScript on the classpath. The fixes for both (piggieback#162 and piggieback#161) will be in the next piggieback release. The Node.js REPL in ClojureScript itself doesn’t cope well with interrupted evaluations, and that one is next on my list.

What’s next

0.1 is the foundation. Here’s what I’d like to tackle next:

• a test runner with proper reports
• a full-screen inspector and stacktrace browser
• an MCP server and a ready-made skill for coding agents
• better Windows support

Try it

The easiest way to install neorepl is bbin:

$ bbin install io.github.nrepl/neorepl
$ cd my-project
$ neorepl

The README has the details.

It’s early days, so I’m sure you’ll find rough edges. Please file issues, and tell me what you’d like to see next. And if you’re one of the people who kept lein repl and REPLy going over the years - thank you! neorepl wouldn’t exist without you.

Keep hacking!

The topic that wouldn’t die. It started with a quick post on Sacha’s solution to a problem posed by David Pape. I thought it was a nice solution but then 0-_-0_ pointed out that abo-abo had already solved this problem with his tiny library. So I wrote about that and prepared to move on.

I was not allowed to. Frequent commenter Phil remarked in my original post that he would use a keyboard macro. He suggested that that would make sense for those of us who who seldom need to enter a sequence of ranges like Pape. In Pape’s case this was something that he needed to do a lot so a solution like Sacha’s or abo-abo’s make sense. I agree with Phil. A keyboard macro is exactly how I would solve this problem given that I seldom have it.

This seems pretty obvious and might not be worth writing about except that Phil’s solution showed me something that I didn’t know: You can set the initial value of the counter with a Ctrl+u n where n is the desired initial value. That’s a lot easier than using Ctrl+x Ctrl+k Ctrl+c to do the job.

As a final note, I think that Phil had a typo in his macro. As far as I can tell it should be

C-u 47 <f3> # <f3> , SPC <f4> <f4> <f4> <f4> <f4> <f4> <f4> <f4>

At least that’s what works for me.

It turns out that I regularly use a macro with a counter so I’m really happy to learn that the counter can be set so easily.

Update [2026-10-10 Sat 12:12]: Fixed link.

In a nice coda to yesterday’s post on Sacha Chua’s solution for entering number ranges, 0-_-0_ points out that a solution already exists. That solution is abo-abo’s tiny library. I vaguely remember seeing tiny when abo-abo released it 13 years ago but I never followed up and used it. Still, anything from abo-abo is worth taking a look at and, in any event, we now have two solutions to the problem.

Abo-abo’s solution brings to mind another Emacs lesson: very often, if you need some functionality, there’s a good chance that it already exists. Of course, that’s not the same as being easily discoverable. An internal function can usually be discovered through the on-line documentation but a third party library like tiny won’t appear in that documentation until it’s loaded.

That’s it for today. I just wanted to tell the rest of the story from yesterday.

I use org-use-speed-commands all the time when navigating and performing actions on org headlines, but I think I have found a friction point, something that just feels a little off.

When the point is on * and then you press the key t, it calls org-todo via org-self-insert-command. Fast, but the feel is off, the point stays on the stars, so I have to move right before I can type the headline.

The reason is in org-todo itself. It has a cursor fixup that parks point just after the keyword, but only when point is not at beginning of line. Speed keys by definition run at beginning of line (org-speed-command-activate requires (bolp)), so the fixup never fires for exactly the keys that would benefit most.

There is no custom option for it, so I added a small :after advice:

(defun my/org-todo-stop-after-keyword (&rest _)
  "Move point to just after TODO keyword when `org-todo' leaves it at BOL.
Speed command `t' (via `org-self-insert-command') runs with point at
beginning of headline, where `org-todo' skips its cursor fixup."
  (when (and (bolp) (org-at-heading-p))
    (when (looking-at org-todo-line-regexp)
      (goto-char (or (match-end 2) (match-end 1)))
      (when (looking-at " ") (forward-char 1)))))
(advice-add 'org-todo :after #'my/org-todo-stop-after-keyword)

Now * Test with point on * plus t becomes * TODO Test with point on Test, ready to type. Same for cycling * TODO to * DONE.

Small change, but speed keys finally feel like they finish the job instead of leaving me parked on the margin!

gravity

Product: Gravity
Price: $9.99

The Problem

We are all familiar with the act of note-taking. A thought occurs to you, you switch to your note-taking application and face a slew of decisions:

• What are we going to call this note?
• What are we going to tag this note? Or which folder does this note belong to?
• How does this fit into my existing tag-system? What was the tag I used a few months ago on a similar note? It belongs to this folder, but also belongs to this other folder, do I alias this note to the other folder?
• Which note is this new note related to? Do I need to link them? What about back links?
• And on and on and on.

Our note-taking systems have evolved into a quagmire. We are now in the business of managing our systems. Instead of taking notes, we work incessantly on our note-taking system. Soon we avoid taking notes, it is too much bother.

Look at the discussions on the Zettelkasten Forum:

• Definitions in Literature Note vs. Zettel Note — Zettelkasten Forum
• Zettelkasten - Term and Definition — Zettelkasten Forum
• Introduction to the Zettelkasten Method - Page 2 — Zettelkasten Forum
• What’s the point of literature notes? — Zettelkasten Forum

Or go to Obsidian Forum. You will see the same discourse. People obsessing over the system.

A Perspective

I had heard of Andrej Karpathy. Couldn’t tell you in what context, but the name was familiar to me. He wrote the following: The append-and-review note – karpathy.

Go read it, it is a small read. I will wait.

His system is two steps: Append and Review. Append to a single file. No tags, no metadata of any kind. This is the line which stood out to me: “When I note something down, I feel that I can immediately move on, wipe my working memory, and focus fully on something else at that time. I have confidence that I’ll be able to revisit that idea later during review and process it when I have more time.”

He periodically reviews his notes moving things which are important at the moment to the top. The rest of the information continues to sink to the bottom, like gravity.

The main advantage of this system? No friction. No decisions at the moment of entering a note/thought. Nothing lost. Nothing falls through the cracks.

Enter Gravity

Gravity is an attempt to provide an environment for this system to work. It can be a menu-bar only application. You press a keyboard command wherever you are. Up pops an editor window. You type or paste in what your thought was. Hit ⌘↵ or three ↵’s. The note is saved. You are back to the program you were in initially.

Periodically you can review your notes. The ones which are more relevant you can nudge up the chain. Everything else keeps getting demoted and drops down the list, like gravity.

Gravity is powered by a SQL database as its back end. You can export your whole repository of notes to a Markdown file, a text file, or a JSON file. So even though it is a database, there is no lock in to the product.

I was intrigued by the following line from the developer, Tristan Manchester:

Gravity has one job: minimize the time between “I have a thought” and “the thought is captured and I can move on.”

That appealed to me and I got curious.

Gravity The Program

gravity - window

A keyboard command, you can customize, from anywhere and this is the Gravity window. All of your thoughts and their content in a window.

gravity - capture

This is the capture window. A keyboard command, customisable, and this window pops up. You enter your thoughts, hit the return key twice, or ⌘+↵ and the content is saved to Gravity. You hit ⇧+↵ key to add a new line. (I notice that a simple ↵ does add a new line too).

In the Gravity window, you have the choice of promoting any entries you need to the top of the list. If you have a long list, this makes items which are relevant to you be readily accessible and it is the premise behind the program. Items which are not relevant for the time being keep sinking to the bottom.

You have the option of archiving or deleting thoughts you want to keep or want to discard.

It is all done in Gravity.

Gravity Preferences

They are well thought out and well designed.

pref - general

You will want Gravity to launch at login. You want it to be always available. I don’t much care for the program to show up in the Dock. You can choose to have the two ↵’s to save the capture or rely on the usual ⌘+↵ command. I like having both.

pref - keyboard 1

pref - keyboard 1

pref - keyboard 1

The program is fully keyboard driven. I love this aspect of the program and they are all customisable. You set your own or stick to the ones shipping with the program. Regular readers know how much I like this feature.

pref - syncing

You can choose to sync to iCloud. That allows the same document in multiple machines. I love it.

pref - search

You can choose to have the archives included in the search. If you have a long list of entries in the current focus and want to move some over to the archive, you can still include them in the search and nothing is left out of your searches.

pref - advanced

This is where you can export your whole collection of notes to a Markdown file, a plain text file or a JSON file.

pref - more advanced

You can monitor some stats about your usage of the program. Optimize your SQL database. There is also a command line tool (I haven’t explored this much. Although I have installed it).

How Well Does Gravity Work?

This is from the developer of Gravity:

I get the same feature request about once a week. “Love Gravity, but could you add folders?” “Would be perfect if I could tag notes.” “Any plans for linking between notes?” “An API would be amazing.” The answer to all of these is no. Not “not yet”. Just no.

This probably sounds like bad product thinking. Aren’t you supposed to listen to users? Give them what they ask for? Iterate toward their needs?

Usually, yes. But there’s a specific reason Gravity works the way it works, and adding these features would break it. The limitations aren’t gaps. They’re the design.

Someone recently asked me why Gravity doesn’t have folders. My first instinct was to say “we’ll add that eventually.” Then I caught myself. We’re not adding folders. We’re not adding tags either, or bidirectional links, or a plugin system, or templates, or a knowledge graph. These aren’t items on a roadmap we haven’t gotten to yet. They’re deliberate omissions. The missing features are the product.

I found this interesting. Mind bending, but interesting. Then I remembered:

Gravity has one job: minimize the time between “I have a thought” and “the thought is captured and I can move on.”

If you are looking for a capture application which is designed to do just that, have a thought, capture a thought, move on with life, then Gravity is the ideal tool for that need.

It is well-designed software which does that and does that well.

Is That All I Need From a Capture Application?

I am old. I forget things. There are too many times during the day when I have a thought and it floats away a few minutes later. For instance, read the Org manual and read the section on narrow and widen. A few minutes later, I have no recall of what I was thinking about. My solution? Capture the thought. Do I want to capture the thought in a stream of thoughts? Or do I want to categorize the thought into a file?

The program I use for this is Capture for Mac. I have a text file which has markdown headings like:

• Ephimeral
• Emacs
• Watch Later
• Read Later
• Programs Installed
• And so on.

The Capture window in Capture gives me the option of inserting the content under a specific heading. It adds a time stamp and some context if I have highlighted something. That is what I use for capture at this point.

You can follow a similar arrangement in Gravity. Prepend some text to the capture. For instance, things about Emacs, can have Emacs: to start with, or Read: for things to read later or Watch: to watch later, and so on. And the system works because the Search function in Gravity is excellent.

I understand that the goals of the two programs are different. They are not solving the same problem. If your need is to record thoughts and move on with your life, Gravity as a system is perfect for that. I love working in it. I admire what it is trying to do and feel it is perfectly designed for that.

Of Course, Emacs

("o" "OBTF" entry
           (file+headline "~/Dropbox/org/obtf.org" "OBTF")
           "Created: [%(format-time-string \"%Y-%m-%d %H:%M\")]\n %?"
           :prepend t
           :empty-lines-before 1
           :empty-lines-after 1)

You know I have to do everything in Emacs. I added this Org-capture template which lets me perform a similar function in Emacs. I can capture content to a file called OBTF.org. I can then refile content to the top or the bottom of the file through danielsz/Palimpsest. I can have an Archive heading and move sections to it through org-refile. All of this is more effort than Gravity, but it has the added advantage of being in Emacs.

Some More Reading

Blog — Thinking About Capture — Gravity

No, We’re Not Adding Folders — Gravity

Conclusion

Gravity is a fantastic application to capture your thoughts. It is a product with a defined philosophy and it sticks to its vision.

I recommend Gravity heartily for your capture needs.

macosxguru at the gmail thingie.

Note: Thanks to Tristan Manchester, the developer of Gravity, for providing me with a promo code when I asked for one.

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

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

This Saturday, 10 October 2026, at 16:00 Europe/Athens time, I will do an “ask me anything” live stream. I have been meaning to do this for a long time, but I never found the chance for it.

Ask me a question about anything—literally ANYTHING—and I will give you an honest answer (e.g. Emacs, philosophy, technology, keyboards, politics, the hut, Français, and more!). It does not matter if the question is personal or sensitive. I will give you a complete answer to the best of my abilities. If you need any ideas, check the rest of my website, where I write at length on a broad range of topics.

The plan is to do a live stream for at least 1 hour. If there are many questions, I will extend it to 2-3 hour or, generally, for as long as needed. And if there are no questions, then I can do something related to Emacs or close the stream earlier—no problem!

Liens :

• Orukeet pour la reconnaissance vocale parce qu'il est assez rapide et assez précis.
• sachac/whisper.el
• speech-input

0:00 Introduction

Je veux vous présenter ma petite expérience de la reconnaissance vocale pour dicter dans Emacs et pour les contrôler. J'utilise le modèle Orukeet pour la reconnaissance vocale parce qu'il est assez rapide et assez précis. Je l'intègre dans Emacs en utilisant mes bibliothèques sachac/whisper.el et speech-input. J'ai récemment créé des commandes vocales pour ajouter des éléments à ma liste de tâches. C'est étonnement utile parce que ça réduit la charge cognitive liée à la mémorisation des raccourcis clavier. Je vais vous montrer cela.

0:37 Ajouter des tâches

Je presse la touche zéro du pavé numérique avant et après avoir dit « Rappelle-moi demain de préparer une présentation pour Emacs Paris sur les commandes vocales. » La fonction crée une tâche dans ma boîte de réception. La tâche est planifiée pour demain. Il y a un lien vers l'enregistrement

1:09 D'autres dates

« Rappelez-moi demain de préparer une présentation pour Emacs Paris sur les commandes vocales », la capture d'écran et le contexte de tâche. Ça m'aident si j'ai été mal comprise ou si j'ai besoin de contexte. De la même manière, je peux dire « Rappelle-moi la semaine prochaine de faire la paperasse pour l'école. » « Rappelle-moi aujourd'hui de créer une vidéo sur mes commandes vocales. »

1:59 Basculer à une tâche

Je peux aussi créer une tâche et déclencher le suivi du temps (ou clock in). Par exemple, je peux dire « Commence à implémenter la génération des questions. »

2:15 Retrouver le fil de mes pensées

Si je perds le fil de mes pensées : « j'en étais où ? » Ça m'affiche les tâches récentes.

2:27 Je faisais quoi ?

« Je faisais quoi ? » Ça bascule sur la tâche actuelle. Voilà des commandes vocales pour ajouter des tâches.

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

Will voice kill the keyboard. No. Will the way we interact with Emacs, and computers in general, change drastically? No.

Star Trek has a mythical AI/computer that responds to voice commands and interacts with you to clarify or note other work that may pertain to what you wanted. Evidently the interface is so ubiquitous that Scotty talks to a mouse noting it's "quaint" to need to push it and type on a keyboard to interact with a computer.

But if we watch the bridge of any Star Trek show people aren't talking the whole time. They're tapping screens to get the computer to do things for them. Theoretically the captain could tell the ship where he wants to go and let the computer do it, but he issues a command and then someone types in the needed commands to the ship so it goes in the expected direction.

I work at home in a solo office space. I could talk to my computer and it would disturb no one, except me. I'd be unable to listen to music on my stereo at the same time just in case the computer couldn't understand my words versus the song.

I don't think keyboards are going anywhere any time soon. They provide an unambiguous interface to your computer that doesn't disturb others. I think that those loving Emacs interactions like they use it will continue to do so as they do now because it's the most efficient way to control the Emacs interface.

The incomparable Sacha Chua has a very nice solution to a problem posed by David Pape: how can we enter a range of numbers as list of distinct numbers in Emacs? Pape’s specific problem was entering the numbers of error reports that a Git commit closes. Rather than entering something like

closes: 47, 48, 49, 50, 51, 70

he’d like to enter something like

closes: 47-51 70

and call an Emacs function to have it expanded into the first example.

Chua has a very nice solution that covers that case as well things like

47-51, 70

or even

5-15/2

to expand into the sequence

5, 7, 9, 11, 13, 15

Most of the heavy lifting is done by the number-sequence function. The rest of the work is parsing the input string into either a single number or a range of numbers that number-sequence can work on.

Chua’s solution strikes me as an example of Emacs at its best. The problem it solves is not earth shattering. It’s simply a bit of friction in a user’s everyday workflow but Emacs easily provides a solution that makes the friction disappear. Take a look at her code. It not only shows an ingenious solution to the problem but also demonstrates the power of Emacs and Elisp to make the application of that genius simple.

Making more use of the keyboard

October's Emacs Carnival theme "Are keyboards and M-x here to stay?" is a good nudge to think about the voice interface I've been experimenting with and where I want to take it.

Like Chris Maiorana, I love the way Emacs's M-x (execute-extended-command) allows me to call any command by name. It means that I can call commands or come up with my own commands without worrying about assigning them to keyboard shortcuts or making sense of where to place them in a hierarchical menu. With flexible completion via the vertico and orderless packages, I don’t even need to type in the full name of the command or remember the words in the right order. If I still can’t remember the command, it’s easy enough to use defalias to make my own nickname for it.

I tend to limit keyboard shortcuts to only my most common commands. Everything else is hard to practise enough so that it sticks in my muscle memory. Even with marginalia showing me keybindings when I use M-x and which-key showing me hints when I pause, it doesn’t sink in.

Maybe I could use key-quiz to drill a small number of keyboard shortcuts I’m actively working on learning, or modify help-quick-sections to show me reminders when I use C-h C-q (help-quick-toggle).

Getting one keyboard shortcut to do the right thing in different contexts is great because it means fewer shortcuts to memorize. Sometimes I can do that by binding the right functions to different mode maps with bind-key, like the way my sacha-org-insert-link-dwim uses the right link syntax in Markdown or OddMuse too. I also like the context-sensitive keyboard shortcuts I get from Embark. I find myself using a handful of those regularly, and C-. (embark-act) starts a bunch of shortcuts across different types of things: i to insert, w to copy, and so on. For example, I know C-x C-f (find-file) will let me select a file to open. Instead of opening it, I can use C-. i to insert the filename into the buffer.

Simpler keyboard shortcuts help. I rarely use the numpad on my laptop keyboard, so those keys can be mapped to functions that don't need to be followed by lots of typing. For example, 0 is a large button. I use it to start and stop speech recognition. Actually, I bind f9 in Emacs to sacha-whisper-run-at-point, and I bind numpad-0 as a keyboard shortcut in KDE (my window manager) instead of just in Emacs so that it's available globally. I'm still on X11 instead of Wayland. The shell script xdotool-emacs focuses Emacs briefly and sends the keys, and the shortcut is set to /home/sacha/bin/xdotool-emacs key --clearmodifiers F9. I do that instead of using emacsclient because emacsclient starts a different buffer, and I might want to keep the context. My sacha-whisper-maybe-type function detects if Emacs is not the focused application and types the text if it isn't, which means I can use it as keyboard input for oher applications while still taking advantage of the corrections and commands I've defined in Emacs. An easy-to-press global shortcut means I can use it from anywhere, even when my foreground app is the browser or another application.

An additional modifier opens up more possibilities for keyboard shortcuts near the regular typing position. My Windows key acts like a Super modifier. I've set it up as a one-shot modifier with Kanata so that I can either hold it down to access more shortcuts or tap it to treat it like a leader key.

There are quite a few commands for which neither M-x nor keyboard shortcuts feel like the right fit: things I want to do faster or more fluidly than M-x, but which I don't do often enough to memorize a good shortcut for. I've been experimenting a bit with voice input, and I really like it.

settings():
    # Adds a small pause (in ms) between each character typed
    insert_wait = 5

    # Ensures modifiers (Shift/Ctrl) don't un-latch too fast
    key_wait = 1.0

Imagining a hybrid approach: keyboard, voice, even mouse/stylus?

I love shifting fluidly from one form of input to another, depending on what makes sense at that moment.

For example, I often start my thoughts by drawing on a light dotted grid using Noteful on my iPad. That lets me quickly cluster ideas spatially, drawing connections and highlighting words as I figure out what I want to say.

Then I use dictation and typing to sketch the outline, jumping around as thoughts occur to me. If I'm livestreaming at the same time, that helps me demonstrate things along the way and lets me benefit from people's questions. Dictation lets me explain things to people and capture the text at the same time.

I can move around with the keyboard, but it would be really cool to use voice for quick navigation between sections of my outline using either line numbers or words. I've implemented a "line" command that lets me jump to a line using the last two digits of its line number, since I probably won't have more than 100 lines visible on the screen at a time. For example, this line is currently 119, so referring to it as "nineteen" would work. I'd like to add more operations for editing the text. I think it would be great to be able to say "kill line 33" to delete that line or "move lines 16 to 20 after 27" to have it move those lines there.

I now have a sacha-whisper-one-sentence-per-line variable that splits up dictation if non-nil, so we'll see where those take me. Orukeet does a reasonable job of punctuating my sentences if I don't pause too much between phrases. My M-q re-wraps paragraphs between one sentence per line, one paragraph per line, and wrapping to fill-column, and it's probably the sort of thing that more voice commands would make even more convenient.

Maybe I can even use that spatial sense of a layout by touching buttons in an Emacs-served webpage on my tablet to direct my dictation to different places. Org-draw uses a similar Emacs web server approach to let you draw on another device and embed the results into an Org file, and there are also simpler HTTP servers (web-server, simple-httpd), so it's probably quite doable. I'm imagining something that takes the top-level items from my current nested list and makes them nice big buttons, so I could have something like "Introduction", "Keyboard", "Reasons", "Experiment", "Hybrid", and "Conclusion", and clicking on those could trigger a POST request to the server inside Emacs which moves my point accordingly. I might even have buttons for various commands. It sounds pretty straightforward to implement.

When my brain comes up with lots of interesting ideas, my org-capture voice commands let me choose which rabbit holes to postpone and which ones I want to dive into.

If I get interrupted by life, I can write on my phone while waiting for the kiddo. Orgzly Revived and Syncthing let me pick up where I left off.

As I get thoughts down, I can use keyboard shortcuts to rearrange things and then convert the list of sentences into paragraphs. I can easily turn text into links using my favourites.

I can imagine combining the audio clips from the text properties with the videos and screenshots to create a quick narrated clip that I can edit (using Emacs, of course), or publishing the narration so that people can listen to it if they like.

This combination of drawing + audio + text works better for me than any of those components alone. Visuals give me anchors for my thoughts. Audio helps with the braindump. Text permits precise, searchable details we can copy. Like George Jones, I find they all have their uses and their strengths.

When I try to dictate longer sections without that kind of visual support, I often lose my train of thought. I want to see where I've been and where I want to go. I don't trust LLMs to clean up that kind of rough transcript; the output doesn't quite resonate with me. I like keeping speech recognition constrained to sentences I can immediately check or reorganize, and I have the recordings as text properties so I can go back to that segment if I need to (at least during the current editing section). That way, I'm never left scratching my head and wondering what I meant.

I love that local speech recognition is getting better and better. I'm curious about whether small language models can do better turn detection to help compensate for my intra-phrase delays when I'm thinking of a word, and whether decision models can automatically classify a sentence into its place in my outline. I think it would be cool if embeddings or other language models could suggest related words or resources as I go along. Lots of interesting possibilities even with the technology that's already available.

Thanks to George Jones for hosting this month's Emacs Carnival on input alternatives. Check out the page for more posts!

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

When I'm working with a tutor to improve my French, I sometimes need to push myself to provide more details when I'm sharing and ask more follow-up questions in response to what they're saying, instead of falling back to « D'accord » and « C'est cool. » Visualizing the timeline in real-time lets me see if the turn-taking looks good. I might even need to take a more active role in controlling the conversation if I happen to be meeting a tutor who tends to go on monologues.

When I'm talking out loud on my own for practice, this might also nudge me to reduce the pauses and enrich my vocabulary by practising saying things often enough that they become more automatic.

;; Report on the balance between my tutor and me
(defvar sacha-vad-tutor-process nil)
(defvar sacha-vad-tutor-dir "~/vendor/orukeet")
(defvar sacha-vad-tutor-command `(,(expand-file-name ".venv/bin/python" sacha-vad-tutor-dir)
                                  "asr.py"
                                  "--spacy-model"
                                  "fr_dep_news_trf"
                                  "-s" "300" "-t"
                                  "VirtualMicSink.monitor=sacha" "alsa_output.usb-AT_AT2040USB_202011110001-00.analog-stereo.monitor=tutor"))
(defvar sacha-vad-tutor-events nil "List of events as an list of alists (label start stop duration).")
(defvar sacha-vad-tutor-labels '("sacha" "tutor"))
(defvar sacha-vad-tutor-summary '(("sacha" . 0)
                                  ("tutor" . 0)))
(defvar sacha-vad-tutor-session-length (* 60 60) "Number of seconds to use for scale.")

(defun sacha-vad-tutor-update-view ()
  "Visualize the last 3 minutes and the overview of the session.
Also keep track of target phrases."
  (interactive)
  (with-current-buffer (get-buffer-create "*tutor stats*")
    (erase-buffer)
    (let* ((total (apply '+ (mapcar 'cdr sacha-vad-tutor-summary)))
           (height 30)
           (width (window-width nil t))
           (max-seconds
            (if sacha-vad-tutor-events
                (apply 'max (mapcar (lambda (o) (alist-get 'end o))
                                    sacha-vad-tutor-events))
              0))
           (threshold 180)              ; last three minutes
           (threshold-seconds (- max-seconds threshold))
           (recent
            (seq-keep
             (lambda (o)
               (when (>= (alist-get 'start o)
                         threshold-seconds)
                 (let-alist o
                   `((label . ,.label)
                     (start . ,(- .start threshold-seconds))
                     (end . ,(- .end threshold-seconds))))))
             (copy-sequence sacha-vad-tutor-events)))
           (recent-total (apply '+ (mapcar (lambda (o)
                                             (-
                                              (alist-get 'end o)
                                              (alist-get 'start o)))
                                           recent))))
      (save-excursion
        (insert
         (format "Last %d minute%s:\n"
                 (/ threshold 60)
                 (if (> (/ threshold 60) 1)
                     "s"
                   ""))
         (mapconcat
          (lambda (o)
            (format "%d%% %s\n"
                    (/ (* 100.0 (cdr o)) recent-total)
                    (car o)))
          (seq-map
           (lambda (group)
             (cons (car group)
                   (apply '+ (mapcar (lambda (o)
                                       (-
                                        (alist-get 'end o)
                                        (alist-get 'start o)))
                                     (cdr group)))))
           (seq-group-by (lambda (o) (alist-get 'label o)) recent)))
         "\n")
        (svg-insert-image
         (sacha-vad-visualize
          sacha-vad-tutor-labels
          recent
          t
          width height))
        (insert
         "\nTotal:\n"

         (mapconcat
          (lambda (o)
            (format "%d%% %s\n"
                    (/ (* 100.0 (cdr o)) total)
                    (car o)))
          sacha-vad-tutor-summary))
        (svg-insert-image
         (sacha-vad-visualize sacha-vad-tutor-labels sacha-vad-tutor-events t
                              width height
                              sacha-vad-tutor-session-length))
        (insert "\n\n"  (sacha-learn-lang-bingo-summary))))))

(defun sacha-vad-handle-end-event (data)
  "Handle the end event."
  (let ((event (list
                (cons 'label (alist-get 'label data))
                (cons 'start (- (alist-get 'timestamp data)
                                (alist-get 'duration data)
                                (or sacha-vad-tutor-start-seconds 0)))
                (cons 'end (- (alist-get 'timestamp data)
                              (or sacha-vad-tutor-start-seconds 0))))))
    (push event sacha-vad-tutor-events)
    (let-alist data
      (incf (alist-get (alist-get 'label data) sacha-vad-tutor-summary 0 nil 'string=)
            .duration))
    (sacha-vad-tutor-update-view)))

(defun sacha-vad-tutor-filter (proc string)
  "Add and parse."
  (when (buffer-live-p (process-buffer proc))
    ;; split the string by newline?
    (with-current-buffer (process-buffer proc)
      (goto-char (point-max))
      (save-excursion
        (insert string))
      (catch 'waiting
        (unless (or (eobp) (looking-at "\n*$"))
          (let ((data (json-read)))
            (when (string= (alist-get 'event data) "end")
              (sacha-vad-handle-end-event data))
            (when (string= (alist-get 'event data) "final")
              (sacha-vad-handle-text-event data))))))))

(defvar sacha-vad-last-speaker nil "Previous speaker.")

(defun sacha-vad-handle-text-event (data)
  (with-current-buffer (get-buffer-create "*Transcript*")
    (set (make-local-variable 'window-point-insertion-type) t)
    (save-excursion
      (goto-char (point-max))
      ;; insert break
      (insert
       (if (string= sacha-vad-last-speaker (alist-get 'label data))
           " "
         (concat (if (bobp) "" "\n\n") (alist-get 'label data) ": "))
       (alist-get 'text data))
      (setq sacha-vad-last-speaker (alist-get 'label data))
      (when (string= (alist-get 'label data) "sacha")
        (sacha-learn-lang-notice-bingo-words (alist-get 'text data))))))

(defun sacha-vad-tutor-start ()
  "Start the process."
  (interactive)
  (sacha-vad-tutor-ensure)
  (setq sacha-vad-tutor-summary '(("sacha" . 0)
                                  ("tutor" . 0))
        sacha-vad-tutor-events nil)
  (with-current-buffer (get-buffer-create "*Transcript*")
    (erase-buffer)
    (display-buffer (current-buffer)))
  (display-buffer (get-buffer-create "*tutor stats*")))

(defun sacha-vad-tutor-ensure ()
  "Start the process if it's not already running."
  (interactive)
  (unless (process-live-p sacha-vad-tutor-process)
    (setq sacha-vad-tutor-process-start-time (current-time))
    (setq sacha-vad-tutor-start-seconds 0)
    (let ((default-directory sacha-vad-tutor-dir))
      (setq sacha-vad-tutor-process
            (make-process
             :name "vad-tutor"
             :command sacha-vad-tutor-command
             :connection-type 'pipe
             :buffer (get-buffer-create "*vad-tutor*")
             :stderr (get-buffer-create "*vad-tutor-err*")
             :filter #'sacha-vad-tutor-filter)))))

(defun sacha-vad-tutor-stop ()
  "Stop the process."
  (interactive)
  (interrupt-process sacha-vad-tutor-process))

;;;###autoload
(defun sacha-js-parse-jsonl-file (file)
  "Parse jsonl as a list"
  (let (results)
    (with-temp-buffer
      (insert-file-contents file)
      (goto-char (point-min))
      (while (not (eobp))
        (condition-case nil
            (push (json-read) results)
          (error (goto-char (point-max))))))
    (nreverse results)))

(defvar sacha-vad-tutor-start-seconds 0 "Number of seconds to consider as the start.")
(defvar sacha-vad-tutor-process-start-time nil "Time that the process started.")

;;;###autoload
(defun sacha-vad-tutor-reset-clock ()
  "Reset the start of the session."
  (interactive)
  (setq sacha-vad-tutor-start-seconds
        (time-to-seconds (time-subtract (current-time)
                                        sacha-vad-tutor-process-start-time)))
  (mapcar (lambda (o) (setcdr o 0)) sacha-vad-tutor-summary)
  (setq sacha-vad-tutor-events nil))

(defun sacha-vad-visualize (labels list &optional output-file width height max-seconds)
  (setq height (or height 25))
  (setq width (or width (window-width nil t)))
  (let* ((svg (svg-create width height))
         (max-seconds (max
                       (or max-seconds 0)
                       (if list
                           (apply 'max (mapcar (lambda (o) (alist-get 'end o))
                                               list))
                         0)))
         (pixels-per-second (/ (* 1.0 width) max-seconds))
         (row-height (/ height (length labels))))
    (dolist (o list)
      (let-alist o
        (let ((y (* row-height (or (seq-position labels .label 'string=) -1))))
          (when (>= y 0)
            (svg-rectangle
             svg
             (* .start pixels-per-second)
             y
             (* (- .end .start) pixels-per-second)
             row-height :fill "green")))))
    (cond
     ((stringp output-file)
      (with-temp-file output-file
        (svg-print svg)))
     (output-file
      svg)
     (t
      (with-current-buffer (get-buffer-create "*vad*")
        (goto-char (point-min))
        (display-buffer (current-buffer))
        (erase-buffer)
        (svg-insert-image svg))))))

(defun sacha-vad-stats (labels list)
  "Return the balance of time talking as (label total percentage)."
  (let* ((max-seconds (apply '+ (mapcar
                                 (lambda (o) (let-alist o (- .end .start)))
                                 list)))
         (durations (mapcar (lambda (o)
                            (cons
                             (car o)
                             (mapcar (lambda (e) (let-alist e (- .end .start)))
                                     (cdr o))))
                          (seq-group-by (lambda (o) (alist-get 'label o))
                                        list))))
    (seq-map
     (lambda (label)
       (let* ((row (cdr (assoc label durations)))
              (total (apply '+ row)))
         `((label . ,label)
           (total . ,total)
           (count . ,(length row))
           (percentage . ,(and total max-seconds (> max-seconds 0) (* 100.0 (/ total max-seconds)))))))
     labels)))

;; (sacha-vad-stats '("sacha" "tutor") (seq-take (sacha-js-parse-jsonl-file "~/proj/speech/output2.log") 5))
;; (sacha-vad-stats '("sacha" "tutor") (sacha-js-parse-jsonl-file "~/proj/speech/output.log"))
;; (sacha-vad-visualize '("sacha" "tutor") (sacha-js-parse-jsonl-file "~/proj/speech/output.log"))
;; (sacha-vad-visualize '("sacha" "tutor") (seq-take (sacha-js-parse-jsonl-file "~/proj/speech/output2.log") 30))

(defun sacha-vad-tutor-group-output (files)
  (let ((grouped-files (seq-group-by
                        (lambda (o)
                          (substring (file-name-base o) 0 10))
                        files)))
    (mapcar
     (lambda (group)
       (let ((start 0))
         (cons (car (cdr group))
               (seq-reduce
                (lambda (prev file)
                  (append prev
                          (let ((max-seconds 0))
                            (prog1 (mapcar (lambda (event)
                                             (incf (alist-get 'start event) start)
                                             (incf (alist-get 'end event) start)
                                             (setq max-seconds (max (alist-get 'end event) max-seconds))
                                             event)
                                           (sacha-js-parse-jsonl-file file))
                              (setq start max-seconds)))))
                (cdr group)
                nil))))
     grouped-files)))

(defun sacha-vad-tutor-make-table (files &optional width height)
  "Make a summary table."
  (let ((labels sacha-vad-tutor-labels)
        (width (or width 500))
        (height (or height 30)))
    ;; combine data as needed
    (append
     '(("Date" "Tutor" "Minutes" "%" "Visualization") hline)
     (seq-map
      (lambda (group)
        (let* ((list (cdr group))
               (base (file-name-base (car group))))
          (if list
              (let-alist (car (sacha-vad-stats labels list))
                (let ((svg-name
                       (expand-file-name
                        (concat (file-name-base (car group)) "-" .label ".svg")
                        "~/proj/french/conversation")))
                  (sacha-vad-visualize
                   (list .label)
                   list
                   svg-name
                   width
                   height)
                  (list
                   (format-time-string "%Y-%m-%d"
                                       (seconds-to-time
                                        (sacha-filename-timestamp (car group))))
                   ;; (org-link-make-string (concat "file:" o) "file")
                   (if (string-match "-conversation-\\([^\\.]+\\)" base)
                       (s-capitalize (substring (match-string 1 base) 0 1))
                     "")

                   (round (/ .total 60))
                   (format "%d%%" .percentage)
                   (org-link-make-string (concat "file:" svg-name)
                                         (concat "file:" svg-name))
                   )))
            (list "?"))))
      (sacha-vad-tutor-group-output files))
     nil)))

(defvar sacha-learn-lang-bingo-word-file "~/proj/french/bingo.txt")
(defvar sacha-learn-lang-bingo-words nil "List of words.")
(defvar sacha-learn-lang-bingo-words-hash nil "Data for the counts.")

;;;###autoload
(defun sacha-learn-lang-bingo-words ()
  "Load the list of words from the file."
  (interactive)
  (setq sacha-learn-lang-bingo-words
        (seq-map (lambda (o)
                   (when (= (length o) 1)
                     (setq o (list (car o) 0)))
                   (setq o (append o (list
                                      (string-trim (replace-regexp-in-string
                                                    " *\\[.+?\\] *" " "
                                                    (car o))))))
                   o)
                 (pcsv-parse-file sacha-learn-lang-bingo-word-file)))
  sacha-learn-lang-bingo-words)

;;;###autoload
(defun sacha-learn-lang-bingo-handler (event)
  "Manually register the event."
  (interactive "e")
    (let* ((pos (posn-point (event-end event)))
           (val (get-text-property pos 'bingo)))
      (when val
        (sacha-learn-lang-notice-bingo-words val))))

(defvar-keymap sacha-learn-lang-bingo-map
  "<mouse-1>" #'sacha-learn-lang-bingo-handler)

;;;###autoload
(defun sacha-learn-lang-bingo-summary ()
  "Summarize the words to say."
  (let ((target (seq-filter (lambda (row) (= (elt row 1) 0))
                            sacha-learn-lang-bingo-words))
        (yay (seq-filter (lambda (row) (> (elt row 1) 0))
                         sacha-learn-lang-bingo-words)))
    (concat
     (if target
         (concat "Target: "
                 (mapconcat (lambda (row)
                              (propertize
                               (car row)
                               'keymap sacha-learn-lang-bingo-map
                               'bingo (car row)))
                            target
                            "; ")
                 "\n\n")
       "")
     (if yay
         (concat
          "Yay! "
          (mapconcat (lambda (row)
                       (propertize (format "%s (%s)" (car row) (elt row 1))
                                   'keymap sacha-learn-lang-bingo-map
                                   'bingo (car row)))
                     (seq-filter (lambda (row) (> (elt row 1) 0))
                                 sacha-learn-lang-bingo-words)
                     "; ")
          "\n\n")
       ""))))

;;;###autoload
(defun sacha-learn-lang-notice-bingo-words (text)
  "Look for the bingo words in TEXT and celebrate when I use them.
Add to `whisper-insert-text-at-point'."
  (when text
    (unless sacha-learn-lang-bingo-words (sacha-learn-lang-bingo-words))
    (let ((found (seq-find
                  (lambda (o)
                    (and (elt o 2)
                         (string-match (concat "\\<" (elt o 2)) text)))
                  sacha-learn-lang-bingo-words)))
      (when found
        (incf (elt found 1))
        (sacha-vad-tutor-update-view)
        (with-current-buffer (get-buffer-create "*Bingo*")
          (erase-buffer)
          (insert (sacha-learn-lang-bingo-summary))))))
  text)

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

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

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

This is a spontaneous live stream. I am working on a new feature for my ‘denote’ Emacs package. The idea is to implement an optional in-memory cache that can help speed up certain operations.

Over at the Dead Parrot BBS, nickb has an excellent post extolling the power of plain text. It’s a notion that’s familiar to all us Emacs users and even more so to Org users. We Org users (or more generally Markdown and other markup users) can write plain text and have it formatted for output in a variety of ways. The point is, the text stays text and is readable even without the formatting.

As nickb says, text written today will still be readable 50 years from now. Sure, UTF-8 and the other Unicode formats can and do add new characters from time to time but text written today will have the same meaning even if new characters are added.

The most important aspect is that you’ll own your data no matter what programs come and go. Emacs isn’t going anywhere but even if it did, it wouldn’t matter. Text will still be readable and something like Org or Markdown will still make intended formatting obvious even if Org and Markdown no longer exist.

Nickb acknowledges that text is not the right answer for everything. You wouldn’t, for example, want to represent a photograph in plain text and there are lots of other examples. Still, for many applications, plain text is not only sufficient but probably the better solution.

David Pape asked:

I just typed

>Closes: #47, #48, #49, #50, #51, #52, #53, #54

into a commit description, all by hand.

Is there a way in Emacs to expand some kind of range description to make this easier? 😅

I want to expand strings like "5-10, 15-18, 3" into numbers.

Hmm, could be useful. It reminds me of how page ranges work, which will be handy if I want to tinker with PDFs. Let's see if something like this works:

(defun sacha-parse-page-range (s)
  "Parse a page range string and return a list of numbers.
Ex: 1-5
2-4, 6-10
1 4 7-9
3-11/2   - this one specifies an increment"
  (seq-mapcat
   (lambda (part)
     (let ((nums (mapcar 'string-to-number (split-string part " *[-/] *"))))
       (if (= (length nums) 1)
           nums
         (number-sequence (elt nums 0) (elt nums 1) (elt nums 2)))))
   (split-string s "[, \t\n\r]+")))

(ert-deftest sacha-parse-page-range ()
  (should (equal (sacha-parse-page-range "5-10")
                 '(5 6 7 8 9 10)))
  (should (equal (sacha-parse-page-range "1-5, 8")
                 '(1 2 3 4 5 8)))
  (should (equal (sacha-parse-page-range "1 4 7-9")
                 '(1 4 7 8 9)))
  (should (equal (sacha-parse-page-range "3-11/2")
                 '(3 5 7 9 11))))

(defun sacha-issue-range (range)
  "Expand RANGE to a list of issues and insert them."
  (interactive "MRange (ex: 1-5, 7): ")
  (let ((s (mapconcat (lambda (n) (format "#%d" n))
                      (sacha-parse-page-range range)
                      ", ")))
    (when (called-interactively-p 'any)
      (insert s))
    s))

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

A long-standing passion of mine is listening to and collecting music. I’m always on the lookout for new music and where I discover it is primarily from internet radio stations. That said, listening to music in such a way is largely a passive activity, where your main focus is somewhere else. The better music players that acknowledge this difference in focus provide mechanisms for remote-controlling them from other apps. So it is with the Triode app for macOS, which leverages Cocoa frameworks (App Intents in particular) to support remote control.

triode.el is an Emacs Lisp library which provides a simple remote control interface to the Triode app. Basic support for selecting a radio station, play/stop, and muting are provided. Not every feature in the Triode app is accessible to triode.el though; this is controlled by the App Intents actually implemented by its developer, The Iconfactory.

Interested readers can learn more about triode.el in its user guide.

triode.el is now available on MELPA. This release joins my other packages that support remote control of music apps on macOS from Emacs:

• now-playing.el - Interface for the Music app.
• shazam.el - Interface for Shazam music recognition.

All the above efforts have been an exploration of malleable computing using Emacs as the main orchestration tool. I plan on posting a more technical deep dive reflecting this work in the not too distant future. That said, if you’re a macOS user who uses Emacs and Triode, I encourage you to give triode.el a try. Also, consider this a plug for Triode app, a well-designed app that does a great job of taking advantage of the Cocoa frameworks to provide internet radio across different devices provided by Apple.

Chris Maiorana asks a provocative question: What’s the future of Emacs? He asks that question in the context of assuming that Emacs will continue to exist for any timeline that matters to us. But how, he asks, will we use it?

The answer that will occur to most of us is speech mediated input á la Star Trek TNG. We’ll simply tell Emacs what we want it to do and it will do it. But think about that for a moment. Would you really want to dictate the code for your latest program to the computer? Or would you even want to dictate your documentation, story, or letter to your computer?

Sure, you could say something like, “Computer write a program to do such and such.” but then you’re not using Emacs at all. The same for asking the computer to write something for you. That—more or less—is here today but most of us don’t like the results and, again, we’re not really using Emacs in those situations.

For my part, my written thoughts are always much better organized than my spoken ones so even with capable voice input, I’d much prefer to use the keyboard. Maiorana agrees. He points back to a couple of episodes from Tales From the Darkside¹ in which people use the keyboard to do magic with the computer. For him, Meta+x is the spell that enables the magic and he’s very attached to it. Like me, he doesn’t anticipate abandoning the keyboard.

What do you think? Will we still use the keyboard or will we move on to something better?

The Emacs Carnival for October is about looking into your crystal ball. I'd love to see what you're looking forward to exploring. Thanks to George Jones for hosting!

• Upcoming events (iCal file, Org):
  • 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 Berlin: In-Person-Only Emacs-Berlin Stammtisch https://emacs-berlin.org/ Tue Oct 13 1900 Europe/Berlin
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Oct 14 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/UTC - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu Oct 15 0000 Asia/Singapore
• Beginner:
  • A list of Emacs learning materials and references (Reddit)
• Emacs configuration:
  • Customize Me (@marcin_bielewicz)
  • [ANN] package-load-indicator: instantly see which packages are loaded within your init file (Reddit)
• Emacs Lisp:
  • Reading the emacs compilation mode source code (01:29:41)
  • Reading some emacs package source code (e.g. comint) (01:20:07)
  • Desafio #1 | Divisão por 5 (Emacs+Elisp) (19:53)
• Appearance:
  • Tip: increase text scale for modes like elfeed-show - @citizen428.net on Bluesky
  • jamescherti/persist-text-scale.el: Emacs: Persist and Restore Text Scale (Reddit, Irreal)
  • Protesilaos: Emacs: ‘doric-meadow’ and ‘doric-mountain’ coming to the ‘doric-themes’
• Navigation:
  • Tip about C-r RET to turn isearch into a minibuffer prompt (@lispwizard@techhub.social)
  • Marcin Borkowski: How many screens left
  • Overriding project.el project root in Emacs | Blog | Jade Michael Thornton (@artfulrobot@floss.social)
  • preview-tab: VS Code's preview tab for Emacs, now on MELPA (Reddit)
• Dired:
  • Tip: dired-async-mode when you're doing long-running actions @citizen428.net on Bluesky
• Writing:
  • Emacs: Obsidian without external packages - citizen428.net
  • Christian Tietze: Watch My EmacsConf Talk: Zettelkasten for Regular Emacs Hackers
• Denote:
  • Protesilaos: Emacs: status update on the ‘denote-data’ cache for Denote
• Org Mode:
  • Isa Mert Gurbuz: Opening org-capture in a new frame
  • org-incremental-writing package (Reddit) - written with agent assistance
  • Sacha Chua: Emacs Chat 31: Pedro A. Aranda Gutierrez - Org LaTeX export with fallbacks (YouTube)
  • Raymond Zeitler: Now org-toggle-timestamp-overlays is Disabled
  • Org-roam-tree update: jit rendering, arbitrary search and more! (Reddit)
  • inline backlinks for org-roam (Reddit)
  • excali-mode 0.2.0: a diagram DSL with explicit placement and Org Babel support (Reddit, Reddit)
  • Github does not preview Org mode files any more (bug)
• Coding:
  • I've used emacs successfully for decades without using LSP or Eglot. Tell me what I'm missing.
  • A package using rope to do python code refactoring in emacs
  • Clutch update: a video walkthrough (PostgreSQL, JDBC, row editing, JSON hover preview) (YouTube 04:17, GitHub, Reddit)
• Shells:
  • Ankit Gadiya: Fix nested Emacs frames (Irreal)
• Web:
  • canvas-browser: a Chromium page in an Emacs buffer, drawn on an Emacs 32 canvas image (Reddit)
• Mail, news, and chat:
  • tootle: A tiny, text-only, read-only, emoji-free Mastodon client for Emacs. (Reddit) Also rougier's experiment in vibe-coding
  • Andros Fenollosa: How I built a WhatsApp client for Emacs without an API
• Multimedia:
  • nfdn: Announcing triode.el - control an app for playing Internet radio (@kickingvegas@sfba.social)
• Fun:
  • Zippy in the mists of time · Curious Musings (@eludom@fosstodon.org)
  • Raymond Zeitler: What is spook?
  • el-gpu demo pix-el.mkv
• LLMs:
  • LLM release 0.33.0, with decisions! (Reddit, Reddit)
  • AI built my Emacs plugin (01:31)
  • Emacs ollama agent demo 01 (02:22)
    • introduction (配音版) (06:04)
    • change font and size (02:22)
    • 網站內容擷取 (01:14)
    • 排序 (02:17)
• Community:
  • EmacsWiki : CarnivalOctober2026 - Crystal ball (@eludom@fosstodon.org)
  • Matei Candea (social anthropologist) is looking for interviewees for a research project on Emacs, its users and its community (@emacs_london@hachyderm.io)
  • Looking for people who want to have a Lisp meetup in Hamburg (@omidmash@social.tchncs.de)
  • Chris Maiorana: M-x and the future of Emacs
  • Roman and Editors ⋄ ffloyd.space (@ffloyd)
  • Switching To Emacs as a Neovim User (Reddit, lobste.rs)
  • Yay Emacs 39: Testing my new streaming functions (01:54:59) working on Emacs News, tinkering with speech commands
    • Yay Emacs 40: Tinkering with my speech commands and working on the schedule for EmacsConf (58:14)
• Other:
  • Let Emacs make you happy (12:05) - Highlight mode, sentences, split windows, Org mode, functions, and navigation.
  • Emacs is now my new rofi (Reddit) - emacsclient + vertico for launching applications
  • nfdn: Announcing Aquí (Irreal) - location finder
  • isled - a personal issue ledger (Reddit) see also org-edna if you want to have task dependencies; mostly AI written
  • Emacs bufferfile.el: Rename, Delete, or Copy Files and Associated Buffers (e.g., clones/indirect buffers) [Release 1.0.9]​
  • qrencode-el 1.6: export QR codes as SVG, get the SVG DOM using Elisp (@ruediger@hachyderm.io)
  • [22] Emacs Reader: Rendering Architecture Refactor and Other Fixes - Dyne.org TV (@divyaranjan@mathstodon.xyz)
• Emacs development:
  • emacs-devel:
    • Getting rid of pathologically slow regexp matches - Stefan Monnier
    • Library for exporting PDF - Cecilio Pardo
    • Explanation of quoting in docstrings
  • * lisp/faces.el (header-line-emphasis): New face.
  • Add a 'syntax-propertize-function' to 'lisp-mode'
  • Indent HTML lists by a consistent width in SHR
• New packages:
  • ebuild-mode: edit ebuild and eclass files (NonGNU ELPA)
  • triode: Interface to Triode app, macOS internet radio (MELPA)
  • pyfun-mode: Major mode for the Pyfun language (MELPA)
  • neofetch: Pretty system information tool for the Eshell (MELPA)
  • latex-to-svg-for-latex: Preview LaTeX math as SVG in LaTeX buffers (MELPA)
  • gptel-annotate: Annotate files or buffers with LLMs (MELPA)
  • clel: Runtime library for ClojureElisp (MELPA)
  • brewpage: Publish buffers/regions to brewpage.app (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.

Version 1.4.0 of the doric-themes, which is currently in development, will include two new themes that draw inspiration from natural settings.

The Doric project is all about restraining the use of colour and being deliberate about the application of typographic styles. The result is a minimalist aesthetic that can make it easier to focus on the contents of the Emacs buffer.

Below are samples of the two themes. For accurate results, click to enlarge the image.

doric-meadow

doric-mountain

Sources

The Doric themes use few colours and will appear monochromatic in many contexts. They are my most minimalist themes. Styles involve the careful use of typographic features and subtleties in colour gradients to establish a consistent rhythm.

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

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

Since moving to Zola as my static site generator, I have had a nice setup for my website. However, a recent update to zola (v0.22 -> v0.23) broke my website (it apparently had something to do with the Tera templating engine that zola uses). This forced me to finally make the move to switching to orgmode as my SSG.

My ultimate goal has always been to build this website purely with emacs and orgmode^[1], and I'm glad now that's the case. Full disclosure however, I did take the help of LLMs to implement this over the weekend. There are still some rough edges to the site, which is why I have this build on a different branch (instead of main) on my website's source repository.

The website is generated via org-publish with the following directory structure for the source code:

.
├── LICENSE
├── Makefile
├── README.org
├── content/
├── lisp/
├── publish.el
├── static/
├── statichost.yml
├── style.css
└── templates/

5 directories, 6 files

The key component is publish.el which exports all of my blogposts (which are orgmode files now) to html files. I also have the htmlize.el file hosted on the git repo for syntax highlighting.

Feel free to peruse the source code of this build if you're interested in the technical details. At its current state, I'm quite happy with how it has turned out. A nice little addition (which is the default behaviour of org-publish) is that I now have a footer entry mentioning the emacs and orgmode version used to build this website!

How will the future affect Emacs? How will it affect the keyboard itself? Will we speak commands to be interpreted by language models? Will we direct a swarm of bots to do our bidding like an over-zealous Howard Hughes with a megaphone? Or, are keyboards and M-x here to stay?

I’ve been thinking back a lot recently on a few of my favorite episodes of Tales From the Darkside, a horror anthology series that ran from 1983 to 1988, a recurring favorite on the Sci-fi channel, later collected on DVD, and probably streaming somewhere today. Two episodes from the first season are particularly memorable for me: “Mookie and Pookie” and “Word Processor of the Gods.” If you’re an Emacs user and haven’t seen these two great episodes of television, you have some homework to do. Google up, or do whatever it is you do when you need to search for something these days, and find these. At the very least, you will recognize the source of the background image I’ve used in countless YouTube video thumbails.

In “Mookie and Pookie” (original air date 11 November 1984) a terminally (pun not lost on anyone) ill young man uploads his consciousness into a computer, leaving behind a special set of printed instructions for his sister, Pookie (Justine Bateman), on how to invoke his spirit in “the network” after he is gone.

Hold that thought in memory for just a moment.

In “Word Processor of the Gods,” (original air date 25 November 1984) based on a short story by Stephen King, a man receives a homebrew computer as a birthday gift from his recently deceased nephew. This special computer gives the user the ability to create, edit, and delete aspects of his own life—basically the power to author reality.

Is any of this reminding you of Emacs yet?

These tales represent the hope and anxiety that people had about computers in the 1980s. Those magical boxes were either angels bringing benefits to mankind or devils that would lead to our doom. With the benefit of hindsight, we can see that computers brought a mixed bag of benefits and drawbacks, but no one wants to go back to a time before we had them.

I feel quite privileged that I got to see the birth of the first person shooter, the Internet, the smartphone, and “AI” (jury still being out on whether or not language models are really “artificial intelligence”), and have lived long enough to tell about it.

But we are drifting here from the thrust of this article, which is basically to pontificate on the question of “How will the future affect Emacs?”

Let’s go back to “Mookie and Pookie” and the image of teenage Justine Bateman typing out programs by hand, on a keyboard, in that episode of Tales From the Darkside. At the start of the episode, the girl who hates computers is nervously typing one command after another, trying to get a feel for this mysterious box. But soon, she’s become a hacker, accessing data banks and interfacing with the soul of her dead brother. We can see she’s not just typing commands but learning magic.

Nothing so closely matches the experience I had learning Emacs. Except, of course, that I was a thirty-year-old man, not a teenage girl.

Nevertheless, “Mookie,” like “Word Processor of The Gods,” is about using the keyboard as a conveyance for invoking magic.

Fast forward to my discovery of Emacs. Using the help system was like opening a book of magic spells. The keyboard was my wand, artist’s brush, sculptor’s trowel, chef’s saute pan, or whatever artistic/magical metaphor you prefer. This magic is achieved by invoking M-x.

Invoking M-x is the most sensuous and gratifying experience in all of computing.

That simple key command opens a whole world of possibilities.

There’s nothing quite like it. Even though I can set a custom key-binding for a frequently used function, I often still prefer not, because M-x is my silver key.

But this is how we use Emacs today. Now, let’s get to the brave new world.

Computing is about choice, especially in our open source communities. That will never change. I don’t know how future developments will affect Emacs, no one does. But I don’t see how it could change much for those who choose to use it over newer and flashier options.

It’s easy to see how a coding agent could nullify a text editor for a segment of users, but that would be applicable to all text editors—not just Emacs.

As any Emacs user can attest, it’s more than a text editor. Learning the ways of Emacs is learning the ways of Lisp which is learning about the nature of computation itself. That journey is worth taking for its own sake. No “agentic” expedient can replace it.

People are still learning and speaking “dead” languages like Latin and Ancient Greek. Because they’re not dead at all. They’re just as vibrant as ever in the places they are spoken (mostly in churches and legal offices) and in the languages that have been built from them.

While I do my best to welcome and understand any new technology, and reserve the right to tinker and test and taste to my heart’s content, I have no immediate plans on giving up my precious M-x. Not for nothing.

The post M-x and the future of Emacs appeared first on Chris Maiorana.

Just a quick offering today on an informative post from Ankit Gadiya about unwanted nested frames in Emacs. The TL;DR is that Gadiya runs Ghostel as his Emacs shell in TUI and demon mode. That works well but he has a script that calls emacsclient to load a file. There’s nothing special about it; it’s just what you’d expect it to be but when he runs it from with Ghostel, it creates a nested frame in the Ghostel frame rather than replacing the Ghostel frame.

The solution is pretty simple. Gadiya changed his script to check if he was in Ghostel, and if so, calls emacsclient with a parameter to reuse the current frame. You can check Gadiya’s post for the details.

For me, the most interesting aspect was how he checked if he was in Ghostel. It turns out that Emacs sets the environment variable INSIDE_EMACS when it’s running a shell or subprocess. I didn’t know that so I learned something new from Gadiya’s post.

Update [2026-10-05 Mon 11:15]: Added link to Gadiya’s post.

As we all discover eventually, age is going to be accompanied by declining eyesight. If you make your living writing and coding, this is going to result in some discomfort as it becomes harder and harder to read the text in books, newspapers, or your screen. You can’t do much about printed matter except to get stronger reading glasses but if you’re an Emacs user—or, really, any other editor—it’s easy to increase the text size on your screen. I find myself doing this more often when writing, especially at night when my eyes are tired.

The problem is that the adjustment doesn’t persist across sessions and you have to make the adjustment for every buffer that needs a non-default font size. James Cherti has a solution: persist-text-scale.el.

The TL;DR is that once you set a new font scale for a buffer, it persists across sessions and furthermore you can arrange for all buffers of a certain class to have the same scale settings. That’s perfect. You can, for example, arrange to have all the buffers you use for writing or reading text be in a larger text while keeping other buffers in the default or even smaller text.

Take a look at the GitHub repository linked above for the details. You might also want to check out the comments in Cherti’s Emacs subreddit announcement where he answers some questions on what he’s trying to accomplish with the package. If you’d like to have certain buffers rendered in a larger (or smaller) font, this package may be just what you need.

Earlier this year I added Ghostel to my Emacs configuration. Ghostel is a terminal emulator for Emacs that uses Ghostty's engine underneath. It is a delight to use especially with the TUI applications.

Nested Emacs frame problem

I use Emacs in daemon mode, and then use emacsclient to open new frames from the daemon. To use the same Emacs daemon when opening files through other programs such as git, sops, I have a small shell script ee configured as my default EDITOR. It opens a new Emacs frame in the terminal.

#!/bin/sh

exec emacsclient --create-frame --no-window-system "$@"

When I run this script from Ghostel, it opens a nested Emacs frame in Ghostel's terminal session.

Solution

Emacs sets an environment variable INSIDE_EMACS for shells and subprocesses. The script use this variable to check if it is launched from Ghostel and use the --reuse-frame flag to open the new buffer in the current frame.

#!/bin/sh

if [ "$INSIDE_EMACS" = "ghostel" ]
then
  exec emacsclient --reuse-frame "$@"
fi

exec emacsclient --create-frame --no-window-system "$@"

We chatted with Pedro about Org Mode, LaTeX exports and font management including alternatives and things you can and can't do depending on your choices.

Update [2026-10-04 Sun]: Looks like the issue with the hand emoji was that there's a regression in TeXLive: LaTeX 2024 produces the PDF with the right fonts and colours, but LaTeX 2026 doesn't.

Links:

• paaguti - Codeberg.org
• Org mailing list

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

Transcript

Expand this to read the transcript

0:00 Opening

Sacha: But first, I will press the go live button because this time I'm going to remember. Okay, now I think we are live. Welcome to Emacs Chat 31. Today we have Pedro Aranda Gutierrez, who is here to talk about all the cool things with Org LaTeX Export. And Prot is here also because he knows a lot more about fonts and writing in multiple languages and all that stuff. So I'm counting on Prot to ask questions when my mind just goes like, ooh, cool demo.

Pedro: Hello, here we are. So yes, I wanted to talk about what is news for all. At least this part, the integration of the basic font management with lualatex is in main right now in Org Mode.

Prot: Very well, very well.

Pedro: I was not expecting that to happen, but it happened. So that's the situation. And I would just like to go stepwise on what you have to do, what you can do, what you can't do with these things.

1:24 Setting things up

Pedro: This is my Emacs 31 compiled a couple of days ago and I'm on devel. I'm on main here, on main for Org mode. I have a small Org file here which initially I'm going to be using pdflatex to compile, with a trick: I'm not compiling in the background, but I have a script here in the terminal to have a bit more of feedback or direct feedback of what is happening. If we go through this... I mean this is basically my template to start any article. It's going to be an article. we are going to use pdflatex. And the other thing is I have a very small thing with the default font. Then I have also the Sans Serif font. I also have some monospaced fonts with it.

2:33 Local variables

Pedro: The things that I have here that might be interesting for people is that another thing that is quite recent for Emacs is that we are starting to have a lot of the configuration variables as local variables. So you don't have to go and get in your init's .el to have anything configured. Why? This is another sort of fight against the windmills I've had. Why? Because with this I can make my Org files more distributable, so I can share them with more people and they don't have to touch anything in their configurations. That's the basic idea. Small little trick that I have is that I'm using fancyvrb for everything instead of listings. And there was somewhere in the documentation, you also have an explanation for how to use fancyvrb to substitute listings and get nice listings in your LaTeX exported by Org. And that's the only thing. Initially, pdflatex, Everything is plain. If I go and just go and export...

3:56 Mini export menu

Pedro: This is a mini export menu I have myself because I think it's much more handy than the export thing that we have in Org Mode. So I did a small one for me. And so I'm exporting to LaTeX and there you see the...

4:17 Basic output with different fonts

Pedro: This was quick, of course, but what you see is I have my serif, my sans serif, and I have my monofont and that's nice, right? So that's one of the things that we always want to have. Now, the next thing is everything would be nice. And now I need my [??], full file where I have the rest of the things that I want to copy and paste into this presentation.

4:49 Adding a code block as source

Pedro: Everything would be nice if I just were to go and add a small command to do things, but I'm only going to be listing the source. So let me just go and check that. If I do like this, so I have a small listing. Why do I need listings? This is partially for my lectures. I want to share code with my students and tell them how to program, right? Or they are in a lab and they need an example of a command that they need to achieve a search and output in the computer. So what I would do, first step, which would also work with pdflatex, is I'm going to go and export the source. If I now go and export the source, I got a second compile, and now you see that I included the command. Nice thing about using fancyvrb here is that as I have fancyvrb here configured, I'm using the listings stuff, but this is the configuration for fancyvrb. I can include things like a frame to separate code from other things in the document.

6:18 The problem with exporting Unicode

Pedro: But now here problems started and this is this was practically what happened two years ago when someone asked in the list how can I do this and the thing is he also wanted to have something like I want to export both so I also want to export the results. Let's see what happens in this case. It's the tree command so it will be showing a couple of files that I have on my on my system and let's see what happens with pdflatex. It seems to be working, but then if you go to the log, and this is why I have the log here, you start seeing a lot of errors. Why? Because it has records that do not exist.

Prot: Missing characters.

Pedro: Missing characters and things like that. So this was the question. How can I solve this? The obvious answer is pdflatex is not as good with UTF-8 extended, so migrate to lualatex. That was one of the things. But you could actually do it. Before going to that, people said, let's go back and put source.

7:45 Trying a different font

Pedro: You already have the different font packages in in pdflatex, so why not using one of the font packages that you have, for example, the Bera fonts. This Bera font here Bera, Bera Sans and Bera Mono should allow you to do what you want to do. I checked. What I'm doing here is I have my local variables. I've refreshed my local variables to include in the packages, the packages for Bera, Bera sans, and Bera mono. Let's see what happens. If I go just for the source, I get the Bera thing. So there should be some sort, I get the Bera font integrated. So there should be some hope with this. Fine. So let's go back into doing things with the results included. Bad luck. We continue to have this problem. This is inherent to pdflatex. Right?

9:05 LuaLaTeX

Pedro: So we have to move to lualatex, right? And now to be able to do what I'm doing here with lualatex and with my script in the background to see what is happening, I just need to get out and get in again. So we were at this point, we had the Bera fonts. Let's go to see the Bera fonts just with a source on lualatex. This is something that some people ask. The Bera fonts don't have the mono font. So we have to move to something else. Fine. That's point number one. And since that does not work...

Prot: Sans also, right? You should have a sans-serif line. I didn't see that.

Pedro: Yes. Exactly. So the Bera fonts, as some people suggested, do not work with lualatex as we want. So if this doesn't work and the corresponding is not one-to-one, so why not go directly into using the full thing with lualatex, right?

10:37 Switching to FreeSerif, FreeSans, and FreeMono

Pedro: The first thing I would have to do is I'm going to get rid of the Bera fonts here in my local variables. I put it at the end. So now with my local variables like this, I'm only going to have packages like enumitem and fancyvrb. I'm going to be using lualatex and now in a very big first thing, what I would have to do is to start with my LaTeX header and then start with my setmainfont. Let's say we use the simple ones, the setmainfont FreeSerif, FreeSans... As always, the fingers are... And here you go with the mono, and with the mono right. Let's try this at this point in time. What will happen? I'm going to be using the free fonts directly with lualatex and with lualatex commands. Let's see what happens here. Starts compiling, starts compiling.

12:04 LuaLaTeX is slower

Pedro: lualatex is slower, yes. That's the main drawback, mainly for people who want to have equations, LaTeX preview. In Org, when they want to have the preview for equations and maths and so on in Org Mode, that is the main challenge because lualatex gets slower, and that will of course make them not be able to get a flashy auto-refreshing display and so on.

12:42 The fonts are rendered

Pedro: But the thing for me and for my manuals, if you want to say it like this, is that first of all we have here the serif fonts, you have the sans fonts, you have the mono font with the free fonts, right? So the next thing that came in was of course, let's see what happens with the listing. Takes longer, but that is something that I can use to show my students how things will look like in the screen. And this was a question that was raised beginning of 2024 in the list.

Sacha: I appreciate your persistence.

13:42 The farmer on the donkey in front of the train

Pedro: Yes. There's this film, Spanish film from the 30s, from beginning of the 30s. It was still Republic before the Civil War. And there's a man dressed as a farmer in Aragon (they are known to be very stubborn) on his donkey on a train track, and the train behind him, and he doesn't move from the track. The only thing he's saying, "You can toot as much as you want, I'm not going to move. If you want to move, move yourself." So he continues. And the train, and the people: "Why don't you move?" At the end, they come to a joint, he continues on the road, and the train takes the other track. When the train goes by, he says, I told you, you had to go another way. So this is more or less, this in Spanish has become a saying. It's more than a phrase. It's a chufla chufla. And I'm a bit of a chufla chufla. When I think that there's something that needs to be done, I can be very stubborn.

Prot: And of course you need to be stubborn because these sorts of things are tricky and they require time. Especially on a mailing-list-driven workflow, you have to listen to what users want. You have to take in feedback. It is a slow process. You really have to be patient and stubborn, for sure.

Pedro: Yes. Basically, my motivation was I know that I need it. Maybe other people don't want to say, but they need it also.

15:35 Unicode and LuaLaTeX

Prot: Can I ask a comment? Can I ask a question here or will you continue? Because I want to clarify the Unicode characters. Earlier we were getting an error. Now we see the tree. Is this because of FreeFont? Is this because of lualatex? Is it a combination? What exactly helped us fix this?

Pedro: Okay, it's a very, very good question. I was forgetting that. So here we have a combination. lualatex is handling the UTF characters very nicely. Something that pdflatex did not or was very difficult to have them done, doing it. The second thing is that Free Mono has these display characters. which is also important. And of course, if you want to use free mono, you need to use lualatex to drive the thing. So it's the three things. You have the right font, the right compiler and the right environment. So the next thing is, of course, also on the list. Once again, I need my full because it's going to be a bit quicker than if I go writing everything on my own. If I go down...

17:00 Emojis

Pedro: There was someone saying, "Hey, I want my emojis."

Sacha: They're very important, you know.

Pedro: Yeah, I know. For me, it's as important as for anyone. Because maybe you want this, or if you're just... If I'm on a manual, I might want to point out things like... And then I go with the hand, with the body, with the hand, with the... single finger which is the S and then I just want to point at things like this for example and to make it... I might want to highlight something that people have to do with this. Let's try with this current configuration. If I try with this current configuration... And there we are going to see the second part of the answer to Prot's question: we start compiling, we start compiling, we start compiling, and then suddenly we have like two characters which are not part of the thing. Why? Because they are not part of Free Font. Or in this case they are not part of FreeSerif. They are not included in FreeSerif. I need something else. There's where the full thing came in.

18:37 Fallback fonts

Pedro: I was very much inspired by what Pandoc is doing. In Pandoc, you can say, "I have my serif font, which is this font. For this font, I want these fallbacks because that's..." Fallback is, first of all, fallback fonts. Fallback is a term used by lualatex to say, if you can't find a character in a font, try to find it in another font. And then, if you provide lualatex with a list of fonts, it's going to be looking up the fonts to get your characters. That's the main idea.

Prot: Let me ask something here, because if you notice the output... Of course, it is not what we want, but it is also not just the tofu, you know, like the missing character. If you notice, there is some kind of a symbol there going on. From what I recall, we have characters and then we have something that is called the grapheme or grapheme cluster, something like that, which is basically characters laid on top of each other to produce the emoji. It seems here that Free Font has the underlying characters, but maybe not the composition codes or something like that.

Pedro: No. It only has some characters. It only has some some underlying characters. For example it only has the... It has the finger, but it doesn't have all the compositions that you need for that.

Prot: Exactly.

Sacha: That one in particular, I think, changes the color of it. So that's why.

Pedro: Yes. And if you look at the, if we go back here, it's saying there's no character at all for the face. But if you go to the beginning, you will also notice that there was some, where was it? I've seen it. At some point, they are also telling you that the thing... where is it? Okay, fine. It's going to take too long to find.

Sacha: It's fine. Besides, you fixed the problem, so you don't have to dig into the old way of doing things.

Pedro: Yes, so that's my main problem right now. So I go and I'm going to go to the... I keep trying to use the teleconference, the conference screen, the shared screen instead of the red one. This is why sometimes I sort of get mixed up. We had this. And I'm just going to go and comment this out because I'm going to go for the new one.

21:39 Fallback configuration

Pedro: For the new one, I have a full example here. Here we go with the fontspec configuration, which is at the beginning. You say, what are you doing there, right? I know it might look a bit scary at the beginning but then if you if you're familiar with what Pandoc is doing it's not that different

Sacha: Nonsense. It's not scary at all. We'll just copy whatever you post.

Prot: Life is simple.

Pedro: Yeah, no, but I mean, that's the basic idea. You have something very similar to this in the actual documentation, both in the docstring and in the manual. So all this process that I'm telling you is also part of the manual, step by step. So let's go for this and let's try to... First of all, I'm going to load my new variables. I'm going to refresh the variables. Let's go.

22:47 Selecting fonts

Pedro: What I'm saying here is I have a main font, I have a sans font, and I have a mono font, right? That's something that I also had here... about here in this part. The next thing that I'm saying is that the font is free serif, which is this mapping, but saying that for main I'm going to use free serif, for sans I'm going to use free sans, and for mono I'm going to use Noto Sans Mono. Why Noto Sans Mono? Because I like it. It's a bit of a change too. So you can also see that you can mix font families and so on. Basically I like it because it's very readable. And it's very accessible. So for this, everything would be what I had before, right?

Pedro: If you have noticed before I compile, you see that each font has its own size. That is sometimes sort of not very nice, right? So what I would do... The next is I'm going to add a property to both the sans and the monophon to say, try to scale them so that they match the lowercase of the main font. That sort of makes them more proportional, better look and feel, right?

24:10 Fallbacks

Pedro: Now comes the really nice thing, the fallbacks. We've said, fallback is what? Fallback is an alternative font I want to add to the document when a character is missing. I could just have a list of different fonts and go with it and have lualatex decide which characters to use. But that would make the whole thing very, very, very slow. So there's one extra step here, which is look at the document, find what kind of Emacs scripts you have in the document. Then, if you need to add fallbacks, add them for the scripts that are present in the document. For example, in this case, we have the emojis. These are the ones that I want to change. But I don't have any simplified Chinese here, so there's not going to be any Han character in the document, so it's not going to be included in the produced LaTeX. That's the whole idea of the fallbacks. You have fallbacks for the fonts that need them. You might want to have fallbacks for sans serif, maybe, if you need it. If not, you can omit it. In this case, we are only having fallbacks here in the serif font, so I'm only going to be adding the serif, the fallbacks for serif. So that's the basic idea. If you go to Pandoc and you read the documentation, you will notice that most of the things are okay. It's not an Emacs Lisp list here or a plist because it's YAML, but it's very similar. I did some state-of-the-art research before actually coming at the end to this definition. So now, before I compile and we see that we have everything we want, I'm also going to show you what is produced.

Sacha: Let's see.

26:46 The LaTeX produced

Pedro: This is the LaTeX that is produced. The important part is here. That's the fallbacks. If you see, I'm only having the Noto Color emoji font being included. Why? Because what I told you before, there is no Han, so there's no character being added there. I don't add the Han font because I don't need it. That's sort of a mini optimization that you may want to have. Next thing...

27:21 Character families should be in the Messages buffer

Sacha: Sorry, how do people find out what keys they need to put into that alist? Can they describe-char for example to see whether they need to put in emoji or some other...?

Pedro: That's a very good question. For that, I need to get to the Messages, or... Oops. I have Warnings... Where is it? You should normally have, in your Messages, a message from Org Mode telling you that it found the characters. I don't know why I'm not seeing it here.

Sacha: Is it maybe in that Tilix window that you have there with a make edit?

Pedro: No, no, no. It's inside the Emacs. And I'm not finding it. I'm not finding it. I don't know why, but it should be there. Normally, Org Mode would tell you that you have these and those characters, that you have the different families. You will also see it if I were to, say... I'm going to move this out so I don't have fallbacks. This would be a basic configuration. So now that I have my fallbacks out, and I go and I... So you see that I don't have fallbacks. And then if I go to the warrings, where is it?

Prot: Maybe messages?

Pedro: To the messages, exactly. I'm sorry, I don't find it.

Sacha: It's okay.

Pedro: But there is a message, I'm sure there is a message which tells you which families or which scripts you have in your document.

Sacha: All right. No problem. I'm sure all of this will come with wonderful documentation because the Org project is very good at that.

30:09 Behind the scenes

Pedro: Yes. We spend a lot of time going through the documentation. The current documentation currently has undergone a lot of scrutiny both by Ihor and by myself. I've rewritten it two or three times to make it clearer as I gained insights into what I wanted to tell people and At one point in time I isolated myself completely. I rewrote everything. I forgot about all the exchanges I had with Ihor and I had my own ideas of what I wanted to say. I rewrote everything from scratch and suddenly Ihor said, this is what I wanted. Currently the documentation is at least a bit more than just usable.

31:00 Refreshing local variables

Pedro: Let's go back to this. As you see... This is something stupid. I mean, you see that this refresh local variables is a small function that I've written myself. Since I'm working a lot with local variables, I'm also trying to have shortcuts for all this kind of things.

Sacha: Oh, I thought C-c C-c did that in the directive.

Pedro: Sometimes it does not, or at least... the case is... I did it myself. I rewrote everything to be sure that I got my local variables, my directory variables, and everything nice as I wanted. Once I have this... Once again... There. If I now go and compile for the last time... What is missing? What have I done wrong?

Sacha: Do you want a series of undoes?

Pedro: I'm going to go the quick way.

Prot: I think there was a missing parenthesis in that.

Pedro: Yeah, somewhere.

Prot: Yeah, yeah, yeah, there it is.

Pedro: No, it looks right, actually. No, yes, because I've copied it from my notebook.

Sacha: It's not doing the thing yet.

Pedro: Yeah, yeah. And that comes... That's something that I... So at least if you do it like this... I don't know why this hand does not work correctly with Noto Color Emoji. Another takeaway. You have to find your own wonderful emoji file. The other one is Apple. Apple Color Emoji has a different [??] for emojis. That's something that I also wanted to highlight. Sometimes you don't get the full... It's important you have to do a lot of look and find. But at least with this you get your... At least with this, what do I get?

33:37 Scaling fonts to match lowercase

Pedro: I get my fonts scaled so that they look more or less the same size, which is a nice appearance. I have my listings and my outputs. And I have my emojis.

Prot: This looks good.

Pedro: This is basically what I need.

Prot: Can I ask something? Two questions, actually. One is, I see the props parameter you have for the... if you switch to your Emacs buffer...

Pedro: Just a second. I was on the wrong stream.

Prot: Okay.

34:17 Specifying the fallbacks

Prot: So you see you have that props, and then you are passing it a string. In the fallbacks, you have a slightly different expression where you have the font set, and then you pass it the font, but for example, with Noto Color Emoji, you are not just passing Noto Color Emoji, you are also passing a parameter to me that looks like the pango markup, whereas the other one looks like something else, another markup. I just want to ask if you know, off the top of your head, if the documentation for Pango and for whatever else that is, is clearly available somewhere so that we can follow it because one issue I always find with LaTeX or with anything that has to do with these complex things is that they assume you are a domain expert. And it's like, okay, just do fonts the way you do it in LaTeX. And I'm like, okay, how do you do it...

Pedro: "No, but how?" Yeah, I know. Exactly. That part is extremely complex. Because in this case, what you're saying is do whatever you do with your normal fonts if you don't have the colon.

35:33 HarfBuzz

Pedro: If you have the colon, then what they say is you need to have, in this case, you need to have the HarfBuzz rasterizer or however it is called. And that... Yes, you're completely right. This is a problem with the documentation. I have... To the best of my knowledge, the only ones that really need harf are the emojis. That's the example. For the rest of the font, at least at this point in time, you don't need, or with this feature set, you don't need any sort of extra things.

36:17 Upcoming work on Babel (the LaTeX package)

Pedro: The extra things will come in the future, when you try to integrate things like Babel, with controlling the fonts in Babel, which I personally already have running, but it's not yet integrated into Org Mode. That's going to take another year, I think.

Prot: But you are persistent, so yeah, you will do it.

Pedro: Yeah, no, no. I mean, I want to have it. I need it also. At least I would like to see it officially sanctioned by whoever needs to sanction it before I retire in two years, so that people can use it once I retire.

37:02 More about HarfBuzz and ligatures?

Prot: Good, good. The other question I have related to this and emoji is I remember when HarfBuzz was discussed in the context of integrating it with Emacs. Maybe that was Emacs 28 or something along those lines. There was this point. Now, maybe I am conflating things, but there was this point that with this included, like you build Emacs with support for HarfBuzz and now it also supports ligatures. Now, a ligature is something that is fancy. Like, for example, you take three characters, like the equal sign in JavaScript, three equal signs, and you make it look like one character. I don't know if this is part of what you are doing here.

Pedro: Well, a very good question. This discussion that there was on Emacs 28 for HarfBuzz (yes or no) and ligatures and all these kind of things has not helped. Let's say it this way... It adds confusion. In this context, sorry to be that clear. Why? Because you have to think it as two different, this is two different, completely different pairs of shoes.

Sacha: Okay, because we're saying it's not LaTeX export.

Pedro: Yes, so I'm delegating as much as I can to lualatex and to all these, so ligatures and things like that are part of LaTeX. I don't want to treat them at all. The only point where I need to sort of touch lower level, which would be like HarfBuzz, for example, is telling lualatex to use HarfBuzz to include some characters. So that's the full question.

Sacha: So far you've shown us how to include Unicode in the output and also how to specify fallback fonts for things like emojis and other things that are not included in your main font. Were there other parts of your very large patch?

Pedro: Oh, the other parts, which are not... Well, I mean, the current state is that we have all this.

39:23 Upcoming talk on accessible presentations

Pedro: We also have support for accessible presentations, and there... In EmacsConf 26, we're going to have a presentation on how this came to life by the person who inspired it, and by the person who wrote it, yours truly. The third thing that we have for that, we also have a lot of things related with metadata management for LaTeX and for PDF documents. That's also something where I directly call on experts to help us because I know what I know, which is at this point I know I don't know. That's my current situation. I know very little about all this document metadata stuff. I'm learning in the process of writing things for accessible presentations. I'm also learning things related with tagging PDFs and the tag PDF and all this kind of packages which are emerging right now and latest. And all this kind of things. This integration, which is starting to be fruitful. I already have... I'm using it with a couple of students who need that. They can access my presentations right now. I'm also sort of using them as guinea pigs, as willing guinea pigs. I'm going beyond presentations to providing them with documents and so on, and they provide feedback about how accessible those documents are and so on. For that, we need help.

41:19 Upcoming work on Polyglossia and Babel

Pedro: Then the other big thing which is still part of our conversation right now is the Polyglossia and Babel packages. Polyglossian Babel for internationalization. For example, Babel is very nice in managing left to right and right to left and things like that.

Sacha: I don't suppose you have a quick demonstration?

Pedro: Not yet. That would be another long presentation to show you all the kinds of things that we can do.

42:02 Chinese, Japanese, and Korean

Pedro: And just before we close this, I've been showing what I mostly hear dominate, which is English, Spanish, or Latin alphabet. But with this package, we also have initial support for when you're using xelatex. There's a package which is called xeCJK to provide simplified Chinese, Japanese, and Korean documents. So this, with lualatex, raw, without any Babel or anything else, raw and monolingual, is also supported. What I basically do is I map what is on Overleaf describing how to do this with xelatex and this package which is called xeCJK. I map that with the same kind of header. You can use this kind of variables to do the same for this Chinese, Japanese, and Korean document.

Sacha: Would you happen to have an example so that people can see what the markup looks like?

Pedro: The markup, I mean, the idea would be instead of using main... I don't have an example here.. But the idea is that instead of calling the fonts main, sans, and mono, you have CJKmain. So you would have something like, the font would be like CJKMain. C, J, K. And the other thing is that you would have to change your compiler to xelatex. That's also very, very well documented in current main Org. So we have it. That would be more or less the effort of the last couple of years and how it has crystallized into things that are already in master.

44:22 The development process

Sacha: I'm quite curious about the development process. Since it's a large change and it's taking a while to develop, what was it like for you to keep it going despite all the developments in Org underneath?

Pedro: Well, it's not that difficult. At the end, I needed to learn to use VC. Last year in Emacs, I'm doing everything from the VC package in Emacs. So I have a nice workflow there to go and get my... I have two... On one side, I'm, of course, going back and putting everything into the main Org git. But I'm also having my own Codeberg with most things that I'm using. With Emacs it's quite easy to go, either modify one and have the things pushed up, or generating the patches so that Ihor blesses them, puts them into main. Or when I'm doing lots of things that I need for a certain point, I go to my Codeberg. There I have my FontSpec 3 branch. There I do my own changes. I check them. I test them. I test drive them. Because, yes, it's been a lot of work to have everything running. But it's always based on real life. And how would... I try to say how would someone do it, who knows a bit about Emacs and a bit about LaTeX and wants to write as little as possible.

Sacha: This is so much better than the other way of specifying a new LaTeX command that just changes the font for that one specific character and then you have to use it for all the emojis that you have in your document. So having it automatically fall back is so much nicer.

Pedro: Yeah, no, I mean, I was not going to go the PDF way of having every emoji that I want, recoded, and then inserted into the document. I tried some. What was it? When did we start? I tried it like eight years ago, and I decided once I have emojis in a nice way, I will use them. So my first manuals, if you go back, the first manuals that I distributed for that specific course did not have any emojis. So I was able to do basically this, which was what I needed for... I started with a header like this. And then when things came and I also needed to go like the scaling, what I did was scale. So this was my beginning in all this. And these were the commands that I always had in the beginning with my lualatex. The moment I moved to lualatex which was when I needed to do things like this. Then once I wanted to go further, then I started. When this came to the mailing list, my first answer was I'm doing this. And then the next question was, what about the emojis? That sort of triggered the rest.

48:12 Retirement

Sacha: You mentioned wanting to retire in two years. I very much hope that you will retire and do even more Emacs.

Pedro: I want to continue because it's a nice pastime. I want to transition from my tool at work, or in this case, my tool at the university, to this is a nice pastime to keep this up and running. It would be a real pity to lose all this.

Sacha: I'm sure we can find you volunteer guinea pigs.

Pedro: I hope I'll get more and more, because the more people test it, the better it will get. And I'm really looking forward to... I mean, I already showed all the things that you can do in the last big... In the last Emacs conference last winter. So I'm not going to repeat this here. So the talk, because I think it's more important to go move on to the next big thing and have people doing accessible documents. I'll keep on top of my donkey with the train behind me until I get Babel and Polyglossia also integrated.

49:41 Fallback fonts

Prot: Nice, nice, nice. Let me ask you the other question I had, which maybe it is simple. Because you mentioned that you want to have local variables so that the documents are portable, which brings me to the question about specifying generic fonts. Like, can you do something like use whatever the system has for Serif, Sans, Mono? Or you always have to specify a font family, like Free Serif, Noto Sans, etc.

Pedro: At this point, this was a very very long discussion with Ihor. Do you want to have generics or do you want to have specifics? I was looking more towards specifics. Why? Because in my experience, I mean, before I started lecturing, I was for a long time in a research and development company. We had European projects. There you had your own LaTeX templates. There you had to specify each and every font. Then in parallel with that, in the company they had their own templates for PowerPoint, for Word and so on, and you had to specify each and every font that you wanted to use. So I've been mapping my experience in my prior life into this. Having font families might be nice. For example, Bera, I said at the beginning, that's one of the things that might be interesting, right? But as you see, even in pdflatex, with Bera, you have to include three different packages. So what's the difference between including three different packages, or directly saying, here, you have three different fonts, one for main, one for... it's only one for main, one for sans and one for... That's the only thing that you have in LaTeX.

Sacha: So, not like the CSS way of specifying multiple fonts just in case one of them is not there?

Pedro: No. I mean, in this case, you are always going to go with what the system has. Normally, most of the fonts that, at least most of the fonts that I recommend to use, are fonts that are included because you have your LaTeX installed underneath. It's not that I'm going to be there with a, I don't know, what was this, what was it? Well, there was this Telefonica font family. No one is going to have it in real life. But the Free fonts are part of LaTeX. Another font that I really like a lot, because it's very, very readable, is the TeX Gyre family. TeX Gyre is very, very readable. They have all kinds of fonts. I'm using two. Why? Because it's part of LaTeX.

53:06 LaTeX versions

Pedro: And by the way, all this that I've shown today can be done with a LaTeX which is basically 2024. What I'm going to be showing in December needs a very, very modern LaTeX. Why? Because accessibility has not been in the wire for the last... Well, it has only been in the wire for the last months. So, the real support for accessibility things comes with very, very modern LaTeX stuff. But this is something you can do with, I mean, Ubuntu 2024, I'm sure, and Ubuntu even earlier, you could also do. Because the LaTeX is not that fancy. I think fallback fonts are already a well-established mechanism in lualatex for a lot of time.

Sacha: Would you happen to know if the widely released LaTeX 2024, for example, might have support for multiple fallback fonts?

Pedro: That should be starting 2020.

Sacha: Okay. So it's just in the Org side where you might say main, this font is just Free Serif, and not Free Serif, something, something.

Pedro: Yeah exactly all right because...

Sacha: I do actually use custom fonts. When I export my configuration, I want to use my handwriting for the titles, but of course nobody else is going to have my handwriting... I mean, it's public but people are not going to go to the trouble of downloading it, so yes, it would be nice to have that fallback. Not that I'm saying, "Please get on your donkey and go in that direction..."

Pedro: No, of course not. But in this case, good news for you, if you have this as a ttf or as an otf font, then you can include that as your main font, and the PDF that you post at the end will have that already embedded, so you can produce your PDFs with your fonts. The thing is, if you want to share the font, if you want to share the source and then have other people compile it, then you have to tell them to install the fonts that are missing. But I think that's something that happens always. You enter a company, they have their own fonts. The first thing that you have to do, if you don't get a pre-installed computer: download the fonts. If you want to produce documents for the company, you have to download the fonts and install them so that you can produce. You don't have a boss telling you, no, the fonts, the fonts, the fonts.

Prot: It's part of the brand, of course, yeah.

Pedro: Yeah, no, no, it's a very important part of the brand.

Sacha: And of course, LaTeX is very good for controlling all these matters of presentation.

Pedro: Exactly. I mean one of the things that I I like most... Once again, here I've tried a couple of times to have a movement in that direction, a bit more control of fonts within a LaTeX document or within an Org document.

56:38 Sans serif fonts are better for accessibility

Pedro: What you can do now is in LaTeX you can go and say no, the main font is SF family. That's the default font so that you have everything in some series. That's something that, by the way, enhances accessibility. Because there are some people who will just collapse with serif fonts and they need sans serif.

57:09 Wanting markup for sans serif

Pedro: The other thing, the step that I wanted to move forward is I want to highlight some words with Sans Serif. Instead of bold or with the emphasis with the italics and so on, why not make some words stand out with sans serif? That's something that I also discussed in the Org list and no one wanted that. That's a pity.

Prot: Because it might introduce new markup, of course.

Pedro: Yes. I would need just one more markup. And I was like, "Another one, please?" "No."

Sacha: I see. I've been just overriding the standard one because, for example, I won't actually underline things. So I just change my underline to be something else. But of course, as a general practice, it's not going to be that useful. You only have so many emphasis characters.

Pedro: Yeah, no, of course. But if you don't want to underline another thing that many people find disturbing or really challenging, this is why I'm saying, let's try to also have the possibility of having a specific markup just for Sans Serif for that. It's all accessibility. I'm quite, how can I say, I'm very sensible to this kind of things. I'm very sensitive to this kind of things. Mainly because I've been from very, very young, I've been very involved in the disability world.

Sacha: I'm looking forward to hearing more about your accessibility improvements in December at EmacsConf. Thank you so much for working on this.

Pedro: You're welcome. Thank you, yes.

Sacha: You showed us Unicode, you showed us emojis, you showed us theoretically how you would do it for non-Latin character sets. It will all be wonderfully documented. And it is now in Org Devel, right?

Pedro: It's in Org Main.

Sacha: Oh, sorry, yes. Org Main. So it'll make it into its release. I'm looking forward to seeing all of that.

Pedro: It should be like Org 10 when it comes into being. People will still need to download stuff and compile it on their own. That's the main problem. That's the only thing that I would like to see advance at some point. But maybe that's with the next Emacs, with Emacs 32.

Sacha: Okay. Looking forward to seeing how that works out. If people are curious, they can find you on the Org Mode mailing list and volunteer to be guinea pigs for various things. Your code is already in main, so it's easy enough to try out. And thank you very much for sharing the demonstration today.

Pedro: Okay, fine. Thank you very much. Just one small comment.

1:00:33 Contacting Pedro

Pedro: I'm also maintaining LaTeX and Beamer in Org. So any bugs, any questions, anything through the mailing list and I'll try to answer as soon as possible.

Sacha: I will end the stream there so people have an hour of wonderful stuff to listen to. Thanks everyone for joining.

Pedro: Thank you.

Prot: Thank you.

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

There are a couple of threads on the Emacs Devel mailing list that, zombie like, refuse to die. They’re essentially the same. One, entitled "ethically" running proprietary code? is an endless discussion of what Emacs should do if a package can indirectly lead to running non-free code. The other, [NonGNU] new: hermes is the same discussion but is particularized to whether Hermes, which is free software but might indirectly lead to a non-free LLM implementation should be added to the NonGNU repository.

The sane people on the list argue that Emacs can’t possibly control what users do with a particular piece of Emacs software and point to EWW as an example. It’s a core part of Emacs and as free as can be yet users can use it to download non-free software and do other things that the FSF wouldn’t approve of.

The true believers, on the other hand, say, “But but but. Someone, somewhere might use non-free software.” Of course they will. Unless you’re RMS who has taken extraordinary steps to restrict his computer use to a tiny part of what’s available, we all use non-free software of some sort. Even if you’re using Linux and are careful about the software you install, what about the BIOS on your computer?

Most of us support FSF and its ideals. We believe in free software and see it as a net positive for our industry. That’s different from taking an absolutist position—as if we were members of some crazy cult—and insisting that nothing we do should ever lead, even indirectly, to the use of non-free software.

Over at the Emacs subreddit, DevelopmentCool2449 takes note of the conversation and briefly discusses how it has opened a schism between RMS and Emacs developers. The action, as usual, is in the comments. Most commenters seem to side with the developers but some are taking no prisoners and hope that Eli Zaretskii quits. This despite the years of unpaid, exemplary service that Zaretskii has given to the Emacs community.

It’s obvious which side of the debate I’m on but good faith arguments can be made on both sides. Still, I wish everyone could agree to disagree and move on.

What is spook?

The Emacs function spook is not what you think it is. It doesn't make creepy noises, draw scary ASCII art or change the theme to orange on black. In fact it has nothing at all to do with Halloween, ghosts, monsters, pandemics or IRS audits.

What it does is insert words and phrases into the current buffer "to help give your message ... attractiveness for automated keyword scanners."

What kind of words or phrases might you expect to see? To find out I invoked spook while composing this content. Here's what it added:

TELINT Drug North Korea Security Consulting Virii Abu Ghraib Fort Hancock CUD AMEMB Vaccine MARTA racal E.O.D. Blizzard Nigeria

It's easy¹ to configure spook to insert an alternate set of words and phrases -- just change the file name in the variable spook-phrases-file from "spook.lines" to the name of the alternate file. Unfortunately it must reside in the Emacs data directory; the file's location is fixed. The variable can be found in the Spook customization group, whose parent group is Games.

Even with only 72 lines in its source code file,² spook demonstrates how to insert one or more random lines from a file into the current buffer.

¹ It's "easy" if you have Administrator permissions.

² The 72 lines is the entire spook.el file; the first 48% of the file provides the usual comments that describe the GNU GPL, author, maintainer info as well as documentation.

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

This is a summary of comments I made at the ‘Root Access’ podcast. They are on the topic of whether to use Omarchy or not on the basis of how one feels about its author.

I personally prefer the complete episode because clips can distort the vide of the event, such as by making me look angry when in fact we are laughing throughout: https://protesilaos.com/codelog/2026-09-27-emacs-live-root-access-show/.

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

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

This is a summary of comments I made at the ‘Root Access’ podcast. They are on the topic of AI-generated contributions to Emacs and the wider discussion on free software politics.

I personally prefer the complete episode because clips can distort the vide of the event, such as by making me look angry when in fact we are laughing throughout: https://protesilaos.com/codelog/2026-09-27-emacs-live-root-access-show/.

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

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);