Yesterday I wrote about James Cherti’s Org-ibullets package. Today I’m writing about another package that he announced at essentially the same time: wizard.el. It’s a package of some carefully written Emacs functions dealing mostly with editing and navigation.

Cherti describes his functions as using the builtin Emacs functions rather than third party packages or writing complex logic de nuevo. It’s surprising how far you can get with just what Emacs provides out of the box.

You can look at Cherti’s post or the source code for a list of the functions but their broad categories are:

• Highlighting functions
• Buffer and State Management
• Smart Text Manipulations
• Search & Replace
• Code Navigation

Cherti has more to say about the functions in those categories so be sure to take a look at his announcement. If one of your goals is to reduce the number of third part dependencies in your configuration, this package may interest you.

Org Social is so simple it looks like it was born before the internet. A single plain text file, an editor and a host are enough to interact with other people.

To "create an account", you just create a plain text file in any editor. Your "database" is your own hierarchy of posts. Your "algorithm" is however you decide to sort other people's posts. There is no "character limit". Your "server" is any hosting or web server. Your "interface" is your favorite editor. And if you want to "delete your account", you just delete the file. And of course, the syntax is richer than Markdown and just as easy to learn: Org Mode. You share and edit wherever you want, and you use it as a microblog, a journal, a forum, a bulletin board or a blog. Your file, your rules.

Behind it there is infrastructure that enriches the interaction and connects it with other systems and formats (the Fediverse, RSS, clients...). Each piece adds one more level of convenience, but none of them is essential: they are 100% optional! And that is what I want to talk about.

I'd like to take it apart piece by piece, explaining what each one does and why it exists.

Layer 0: a plain text file

Everything starts and ends here. A file called social.org, in UTF-8, with LF line endings.

The header is your profile. They are Org Mode keywords:

#+TITLE: My journal
#+NICK: Alice
#+DESCRIPTION: I write about Emacs and coffee
#+AVATAR: https://alice.com/avatar.jpg
#+LINK: https://alice.com
#+FOLLOW: https://bob.com/social.org
#+FOLLOW: friend https://carol.net/social.org

Below it, in a * Posts section, go your posts. Each one is a heading with an RFC 3339 timestamp, which works as a unique identifier:

** 2025-05-01T12:00:00+0100
:PROPERTIES:
:LANG: en
:TAGS: emacs org-social
:END:

Today I discovered Org Social and I can't stop writing.

And you already have a social network.

Anyone can curl your file, read it with their own eyes or with a client or script, and follow you by adding your URL to their #+FOLLOW:.

The interaction itself lives inside the format. There are no magic buttons, there are properties:

• Replying is a post with :REPLY_TO: <url>#<id> pointing to the original.
• Reacting is a reply with just :MOOD: ❤ and an empty body.
• Sharing is :INCLUDE: with a reference to someone else's post.
• Voting in a poll is replying with :POLL_OPTION:.
• Mentioning someone is a link [[org-social:https://bob.com/social.org][Bob]].

Since it is plain text, you can edit all of it by hand if you feel like it.

When you are done, you save the file and upload it to your server.

Every decentralized social network has a weak spot, whichever one comes to mind. I covered this in There is no such thing as full decentralization, but in short, you always have to decide which of these five things the network sacrifices:

• Identity
• Connectivity
• Discovery
• Cost
• Moderation

Org Social sacrifices discovery. Nobody can find you unless you give them your URL, just like an email address. And that makes some interactions impossible to reconstruct. For example, what happens if someone you don't follow joins a thread you started? If you don't follow them, you never find out.

That's why we need upper layers that mitigate the problem, although you should only use them if you think you need them. It may be that everyone taking part follows each other and needs nothing else. Otherwise, you will need a Relay: an index.

Layer 1: the client

You can check each feed directly with curl or with your browser. However, just like with your list of RSS/Atom feeds, what we all end up doing for convenience is using a client. It reads every source, sorts them, filters them and merges them into a list that is easier to read and that you can also navigate. The same goes for Org Social.

There is a client for Emacs, another for iOS, another for Android (in alpha as I write this), command line implementations and a public web viewer that needs no account or client. Clients build a timeline by merging all the feeds you follow, and they let you reply, react, share and vote in polls. But every change happens in your own file, not on a central server, and reading is volatile, since it is built on the fly.

The client also acts as a translator between Org Social and the interface you choose. And it is a good way in for people who are already used to X/Twitter or Mastodon, or who don't want to bother learning the syntax.

Layer 2: the Relay

The Relay is a server that crawls the network of social.org files and builds an index: users, mentions, replies, groups and threads. It does this by reading the #+FOLLOW: lines of every feed it knows and downloading the files it finds. You can also register your feed manually so it reads it.

It doesn't store content, only addresses. It notes who mentions whom, what replies to what and what belongs to each thread.

Now you can write a client or a script that asks the Relay for the information that fills in the parts where you were blind before:

# Who mentioned me?
curl "https://relay.org-social.org/notifications/?feed=..."

# Give me the full thread of this post
curl "https://relay.org-social.org/replies/?post=..."

# Find everything about Emacs
curl "https://relay.org-social.org/search/?q=emacs"

And that's not all: anyone can run their own Relay, locally or on a server. Their instance will connect to other public Relays and they will exchange information, so the whole network knows which feeds exist and how they relate.

It also offers other features, such as real-time notifications, RSS/Atom feeds, post search and bridges to ActivityPub/Mastodon. Yes, you can follow Mastodon accounts from Org Social, or keep up with Org Social from your favorite RSS/Atom reader.

Layer 3: Org Social Host

Needing your own hosting just to start taking part in the network is a tough requirement. That's why there is a free and open hosting service, integrated with the clients, that puts your social.org online with a single click.

You pick a nick and get two addresses:

• public-url: the one you share with everyone, for example https://host.org-social.org/alice/social.org.
• vfile: a secret, signed URL that works as a password. Whoever has it can overwrite your file, so keep it safe.

If you use a client, all of this is automatic and you never even see the secret URL, since it is stored in your configuration. It all happens behind the scenes.

If you are curious, signing up is a single request:

curl -X POST https://host.org-social.org/signup \
  -H "Content-Type: application/json" \
  -d '{"nick": "alice"}'

And overwriting your file, another one:

curl -X POST https://host.org-social.org/upload \
  -F "vfile=YOUR_VFILE" \
  -F "file=@social.org"

It doesn't lock you in either. You can ask it for a permanent redirect (HTTP 301) to your new URL and your followers won't even notice. Their clients follow the redirect on their own, although it's a good idea to let them know so they update their #+FOLLOW:. It is a way in, not a requirement.

You can also run it on your own server, with public sign-up disabled and your own domain.

And it has an advantage that seasoned app developers will have guessed already: it makes syncing between devices easy. You can, for example, write in the mobile client and carry on in the Emacs one with simple HTTP requests. No old protocols, no third-party APIs.

Layer 4: Mirror or CDN

Do you use an RSS/Atom reader? Then you already know that the more feeds you follow, the slower it gets.

It doesn't matter how fast and parallel the downloads are. There will always be dropped connections, timeouts, errors and redirects. And if a feed is very large, the client has to parse all of it to keep what it cares about.

In my case, I follow 250 feeds. Download and parse them every time I scroll? Not viable. Cache them? Then the problem becomes when to invalidate the cache.

This is where the Mirror comes in. It is a server that keeps an up-to-date copy of every feed and saves you the parsing, sorting, thread building and mention consolidation. It exposes a simple REST API that returns JSON ready to use in a client.

You can think of it as a client of clients, or a general-purpose client without an interface. Internally, it works non-stop to keep the most recent copy and to prepare the processed information so it is easy to consume.

For example, if I want to build the timeline with Bob's and Carol's posts from the last 14 days:

curl --get "https://mirror.org-social.org/api/posts/" \
  --data-urlencode "following=https://bob.com/social.org" \
  --data-urlencode "following=https://carol.net/social.org" \
  --data-urlencode "sinceDays=14"

It doesn't replace the Relay. In fact, it needs it to know which feeds exist and which ones have changed. And most importantly: it is read-only. It never edits or deletes anything at the source. To publish, you still write to your own file. Its only way in is a webhook that a client can call to say a feed has changed and the Mirror should update it:

curl -X POST "https://mirror.org-social.org/api/webhook/refresh/" \
  -H "Content-Type: application/json" \
  -d '{"feed": "https://alice.com/social.org"}'

It is optional. The client calls it right after publishing or uploading a new version of the file to your hosting, so the Mirror updates its copy straight away instead of waiting for the next refresh cycle.

Layer 5: Push

The Relay already sends real-time notifications with Server-Sent Events, which clients can listen to in order to tell you about mentions, replies and reactions. But phones don't let an app keep connections open in the background, so there you need push notifications. It is the most specific layer of all, since each platform, iOS and Android, has its own notification system with its own certificates and tokens.

If this layer goes down, all you lose is the convenience of getting alerts on your phone while the app is closed.

Layer 6: Live Preview

An Org Social post has an address in the format https://<host>/social.org#<timestamp>. For example, my first post: https://host.org-social.org/andros/social.org#2025-08-14T09:11:00+0200. It works fine between Org Social clients, but what happens if you want to share it on another social network? Nothing pretty: the whole social.org file gets shared.

Live Preview turns a post into a web page. You give it the post URL, it downloads the original social.org (straight from the source, not through the Relay), finds the post and generates an HTML card with its Open Graph metadata: nick, avatar, text and date. Ready to share on any social network.

For example, the URL above becomes:

https://preview.org-social.org/?post=https%3A%2F%2Fhost.org-social.org%2Fandros%2Fsocial.org%232025-08-14T09%3A11%3A00%2B0200

And if I share it on social media, it looks like this:

Clients also use this link format in their share option.

The same need gave birth to another very interesting feature: generating an HTML blog from your social.org, if it is hosted on host.org-social.org.

For example, my Org Social web version would be preview.org-social.org/blog/andros.

You write in Org Mode, upload the file to the hosting (with a simple curl if you like) and your HTML blog is generated automatically, ready to share. It isn't perfect, since you don't control the design, but it saves you from running a static site generator.

Summary

In the end, they are not layers, but pieces orbiting around your social.org.

flowchart TB
    File["social.org"]
    Client["Client"]
    Relay["Relay"]
    Host["Host"]
    Mirror["Mirror"]
    Push["Push"]
    Preview["Live Preview"]

    Client -- "reads and writes" --> File
    Client -- "uploads and syncs" --> Host
    Host -- "hosts" --> File
    Host -- "registers feeds" --> Relay
    Relay -- "indexes" --> File
    Client -- "mentions, threads and search" --> Relay
    Mirror -- "which feeds exist and which change" --> Relay
    Mirror -- "copies" --> File
    Client -- "JSON timeline and webhook" --> Mirror
    Relay -- "real-time notifications" --> Push
    Push -- "phone alerts" --> Client
    Preview -- "reads" --> File
    Client -- "share link" --> Preview

Whatever you use, the only essential piece is your social.org.

If every Org Social server shut down tomorrow, what would you lose? Convenience. And what would you keep? Your file, intact, on your disk. You upload it anywhere else and keep posting.

Few social networks can say the same.

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-6c165f77@andros.dev to leave a comment. The subject will be ignored.

The ever-officious minions have staged what they’re calling an intervention. They told me that I’ve milked this illness shtick long enough and that it was time to get back to work. They were unmoved by my protestations that I was not yet 100 percent and merely pointed at my computer. They obviously don’t understand the meaning of “minion”. Anyway, I’m trying to get things back to normal.

James Cherti has announced a simple package that trades Org mode’s heading stars for UTF-8 bullets. If you’re like me, your first thought is, “Doesn’t that already exist?” Sort of. What already exists is the no longer maintained org-bullets. Cherti’s package is called org-ibullets (note the i).

Cherti explains the differences from org-bullets in his announcement. The TL;DR is that he’s optimized org-ibullets by eliminating redundant computations, eliminated spurious syntax warnings that org-bullets could produce, and made some improvements at the source level.

As I said, the package is simple. It can be used right out of the box but you can customize the list of bullets and their face if you desire. This seems like a very nice package if you’d like to make your Org buffers look a little nicer.

It's October. New month, new agent-shell update. If you missed the last post, have a look at the 0.78 update. While the latest changes are focused primarily on bugfixes and polish, we have a handful of new features too.

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

What's agent-shell?

agent-shell brings your favorite AI agents to Emacs, keeping you at home: familiar buffers and bindings, no terminal emulation. All powered by ACP, the Agent Client Protocol.

Happy birthday agent-shell

I introduced agent-shell just over a year ago, with support for two agents: Claude and Gemini. Today, it speaks to 23.

Development hasn't let up either. Improvements and new features land every month.

Thank you to all users, contributors, and sponsors.

New supported agents

A couple more join the family, bringing it to 23 agents. As usual, they're all reachable via M-x agent-shell, or go straight to the new ones:

• Junie (JetBrains), #847 by @thanhvg. Start it with M-x agent-shell-junie-start-agent.
• OpenClaw, #878 by @jtmoulia. Start it with M-x agent-shell-openclaw-start-agent.

Animated prompts

With the ability to prompt at any time (see my last post), you can queue prompts or steer agents straight from the persistent shell prompt. Animating the prompt ties it all together: it's now obvious at a glance that the agent is busy, and that anything else you submit will queue.

Check out agent-shell-prompt-busy-frames for relevant customizations (more on that shortly).

Thanks to @cark for the proposal.

Busy indicators get further customizations

The header's busy indicator has been animated for some time now. Amongst the existing customizations, agent-shell-show-busy-indicator could turn it off altogether. Having said that, there's now a middle ground: use static text via agent-shell-busy-indicator-frames.

Just set it to a string like so:

(setopt agent-shell-busy-indicator-frames "(busy)")

If you'd like to use smarter logic, you can now set it to a function as follows:

(setopt agent-shell-busy-indicator-frames
        (lambda ()
          (if (agent-shell-session-id)
              "(busy)"
            "(connecting)")))

agent-shell-prompt-busy-frames takes all the same forms, so the prompt's own animation can also be a list of frames, a static string, or a function.

Queue merging

With the new agent-shell-prompt-queue-merge setting (enabled by default), pending prompts are joined (separated by blank lines) and submitted as a single turn. Queued prompts are typically follow-ups to the same instruction, so the agent now sees them together rather than acting on the first before reading the rest.

If you prefer the previous behaviour, disable it with:

(setopt agent-shell-prompt-queue-merge nil)

Thank you @Gleek for the proposal.

While on the subject of queueing, cancelling now offers to continue with the queue rather than quietly dropping it, and killing a shell now warns you about the pending work you'd lose.

More idiomatic completion

@ and / completion used to bundle two things: how to complete, and when to pop up. Turning the popping off lost completion altogether, leaving corfu and company users out.

They're now decoupled. The completion functions are always registered, so completion-at-point, corfu and company work either way. Two options decide whether completion pops as you type: agent-shell-file-completion-enabled for @ and agent-shell-command-completion-enabled for /. For example, listing files can be slow in a large project, so to only complete @ on demand while / keeps popping:

(setopt agent-shell-file-completion-enabled nil)

Trailing spaces (and @ mention quoting) are now only inserted on a finished completion, fixing the stray spaces corfu and company users were seeing.

Thanks to @bcc32 for proposing the split and separate @ and / options in #537, and to @jcubic for filing it and flagging the stray spaces.

Moving by blocks

C-M-a and C-M-e (beginning-of-defun and end-of-defun) now move between blocks. Thank you @OSadovy for #876.

Customizable chat labels

Chat mode draws "Me" and "Agent" labels (or rather "Claude", "Codex" etc.). If the current style isn't your jam, agent-shell-chat-label-function now lets you draw them yourself. It's handed an alist with :text and :role (either user or agent), and must return a single-line propertized string.

The display property is honored, so labels can also be rendered as images. Thanks to @nhojb for the idea.

Parseable transcripts

Transcripts now open with YAML frontmatter, including a start timestamp as follows:

---
agent: "Claude"
started: "2026-10-11T09:30:12+01:00"
working_directory: "~/stuff/active/code/agent-shell"
session_id: "0f3c9a1e-5b7d-4e2a-9c81-6d4f2b8e7a35"
model: "claude-opus-4-5"
---

Thank you @vermiculus for #854.

While on topic, transcripts also got a little sturdier, thanks to @mrcnski's proposal.

M-x yank-media support

M-x yank-media now pastes images straight from the system clipboard (#853), no external utilities needed, the same way Org mode handles it. Pasted image previews also survive being queued or steered, thanks to @Gleek for #852.

Codex config options

Codex gained agent-shell-openai-default-config-options for setting config options at session start, reasoning effort included. For example:

(setopt agent-shell-openai-default-config-options
        '(("reasoning_effort" . "high")))

Thank you @ianthetechie for #855.

Tool call output

Tool call output can be fairly long. A single chunky line was enough to bog a buffer down. Long tool output lines are now limited (#844 by @Gleek), and fallback titles are truncated so they no longer flash chunkily as they stream.

File summaries also count distinct files now, so reading the same file three times counts as one file rather than three (#863, also by @Gleek).

A bunch of fixes

While we have a handful of new features, the bulk of this release went into fixes.

Rendering:

• Emphasis no longer swallows asterisks inside inline code (#870).
• Bold around inline code now renders, as does a trailing quote or header line.
• Streamed tables keep their alignment and markup (#868).
• M-x agent-shell-copy-as-markdown no longer mangles bullets carrying bold text (#867).
• Expanding or collapsing an item inside a group now works mid-stream.
• Chat mode no longer hides notices rendered above the live prompt.
• The graphical header no longer gets cut off when showing cost (#849).
• Terminal hyperlinks (osc-8) are rendered (#850 by @gnufied).

Performance and responsiveness:

• Severe cursor lag from large collapsed tool outputs is gone (#839).
• Bare path:line references are now found in linear time (#848 by @catern), and failed searches leave point where it was.
• Heartbeat ticks skip redrawing when the busy frames haven't changed.
• In acp.el, draining the agent's output is now bounded in how long it holds the main thread (#32 by @moyotar), so a chatty agent no longer makes Emacs feel laggy.
• In shell-maker, launching a shell with visual-wrap-prefix-mode enabled no longer hangs Emacs (#842).

Elsewhere:

• Forking resumes the session, and keeps the fork rather than falling back to another session if that resume fails (#871).
• Grouped config options are handled (#851), and a missing config change event is now emitted (#864).
• display-buffer-overriding-action is preserved when displaying asynchronously (#846 by @bcc32), and docstring command binding specifiers are fixed (#845, also by @bcc32).
• Shell command output now runs in the shell's directory via its file handler (#879 by @junyi-hou), which matters for TRAMP users.
• The README gained guidance for agents hanging at "Loading…" over TRAMP (#872), which turned out to be about tramp-remote-path and direct async processes rather than a bug.

News on the welcome screen

New shells now show the last few release posts on the welcome screen, so they are a little more discoverable.

Public functions

A few additions for package authors building on agent-shell.

Knowing when a shell is ready

agent-shell-initialized-p returns non-nil once the handshake, authentication, session and any default options are all done. Until then, subscribe to the new init-finished event via agent-shell-subscribe-to (#860).

Reading and setting config options

Agent config options are now reachable from elisp rather than the UI alone:

(agent-shell-config-options)
(agent-shell-config-option :category "thought_level")
(agent-shell-config-option-value :id "effort")
(agent-shell-set-config-option-value :id "effort" :value "high"
                                     :on-success (lambda (_) (message "Set")))

Other bits

• agent-shell-last-activity-time returns when the shell last saw a submitted prompt or an incoming notification (#856), handy for idle tracking.
• M-x agent-shell-save-traffic writes the session's ACP traffic to a .traffic file and reveals it in dired, simplifying the bug-filing process.

New third-party package

agent-shell-gc joins the lot, bringing buffer garbage collection (auto-kill) to agent-shell.

Housekeeping

If you peeked at the commit logs for the period, you'll see it's been a busy few weeks. Since the last post, 125 commits shipped, 33 issues have been closed and 15 pull requests merged. As of this writing, the backlog sits at 4 open issues and 6 open PRs (versus 16 and 6 last time around).

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

As usual, this chart was generated using the /github-activity skill shared in my emacs-skills repo.

Four open issues is the lowest it's been since the project's first week, which I'm pleased about.

All of this requires daily attention.

Paying for tokens? Consider funding agent-shell.

Tokens keep your agents running. Sponsors keep agent-shell running.

agent-shell is built and maintained by me, an indie dev, while the tools it competes with have well-funded teams behind them. Vendor-neutral tooling matters more than ever.

Using agent-shell at work? Ask your employer to sponsor too. Companies can contribute at a scale individuals can't.

Pull requests

Thank you to all contributors for these improvements!

agent-shell

• #797: Render ACP elicitation forms (@OSadovy)
• #844: Limit long tool output lines (@Gleek)
• #845: Fix docstring command binding specifiers (@bcc32)
• #846: Preserve display-buffer-overriding-action when displaying asynchronously (@bcc32)
• #847: Add Junie (@thanhvg)
• #848: Find bare path:line references in linear time (@catern)
• #850: Add support for rendering browse-url-data with osc-8 sequences (@gnufied)
• #852: Preserve pasted image previews in queued and steered prompts (@Gleek)
• #854: Emit parse-able YAML frontmatter for transcripts (@vermiculus)
• #855: Add tunable for default Codex config options (@ianthetechie)
• #862: Mention agent-shell-gc package in the README (@izeigerman)
• #863: Count distinct files in read, edit, and delete summaries (@Gleek)
• #876: Move by blocks with beginning-of-defun and end-of-defun (@OSadovy)
• #878: Add OpenClaw agent support (@jtmoulia)
• #879: Run command output in shell directory via file handler (@junyi-hou)

acp.el and shell-maker

agent-shell stands on acp.el to speak ACP and shell-maker for its shell foundations, so fixes landing there reach you just the same:

• acp.el #32: Bound how long a single drain holds the main thread (@moyotar)
• shell-maker #46: Fix byte-compile warnings, runtime cl-lib, defvar ordering and lazy-org declarations (@tothedarktowercame)
• shell-maker #48: Quote mode-map before splicing into eval'd define-derived-mode (@necaris)

Make it sustainable, sponsor agent-shell

As of this writing, we're 88% of the way to the 150 monthly sponsors goal. If agent-shell is part of your daily workflow, please consider becoming a monthly sponsor (or ask your employer to).

Not in a position to sponsor? A GitHub star helps with exposure and brings in new users.

People have been having lots of fun playing Emacs Golf over in r/emacs. Check out the "Fun" category for some examples of people comparing how few keystrokes they need in order to get something done.

• 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 12 1900 CET
  • Emacs Paris: S: Emacs workshop in Paris (online) https://emacs-doctor.com/ Tue Oct 13 0830 America/Vancouver - 1030 America/Chicago - 1130 America/Toronto - 1530 Etc/UTC - 1730 Europe/Berlin - 2100 Asia/Kolkata - 2330 Asia/Singapore
  • 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
  • OrgDevMeetup https://bbb.emacsverse.org/rooms/orgdevmeetup Sat Oct 17 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/UTC - 1800 Europe/Berlin - 2130 Asia/Kolkata – Sun Oct 18 0000 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Wed Oct 21 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/UTC - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Oct 24 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/UTC - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
• Beginner:
  • Keith Waclena's "Use GNU Emacs the Plain Text Computing Environment" (Reddit)
  • Tips for beginners (@andyc@yakshaving.social)
• Emacs configuration:
  • Marcin Borkowski: Repeating commands
  • Tip about setting whitespace-global-modes so that it excludes some modes (@ablatedsprocket@hachyderm.io)
• Emacs Lisp:
  • Desafios em Elisp | Emacs / Magit (01:47:11)
• Appearance:
  • [NEW] emacs32 master branch support scaling for underline, overline… face
  • Ayu themes for Emacs: night, dusk and day, built from the official palette (Reddit)
• Navigation:
  • Tip about using C-x 0 to delete the current window (@lispwizard@techhub.social)
  • Tip: Use registers to save window configurations with C-x r w (@lispwizard@techhub.social)
  • Tip about setting scroll-conservatively (@BeefGriller@dice.camp)
  • persp-mode-tab-bar: Tab bar for persp-mode / Doom workspaces (Reddit)
• Writing:
  • joc-toggle-case.el: toggles case at point (@vnikolov@ieji.de)
  • TAONAW - Emacs and Org Mode: Emacs Config Gems - Part 6 - abbrevs, grammar, Harper, LanguageTool
  • markdown-ts-appear: Rendered Markdown, editable in place (Reddit, lemmy.ml)
  • GitHub - rjprins/markdown-modern: Modern visual styling for Markdown buffers in Emacs (fork of mark-graf) (Reddit)
• Denote:
  • I tried to move my notes out of Emacs. I failed. Again. — baty.net (HN)
  • Protesilaos: Emacs: spontaneous live new ‘denote-data’ feature (2026-10-07 at 18:00 Europe/Athens) (YouTube, 01:22:16)
  • Protesilaos: Emacs ‘denote-data’ testing live today, 2026-10-12, at 16:00 Europe/Athens (YouTube)
• Org Mode:
  • Org Mode requests: [TASK] Re: orgmode: do textsec-url-suspicious-p for http and https links
  • James Dyer: Org Speed Keys: Making t Land After the TODO Keyword
  • Deeper layers of Org Mode laziness explained (Reddit)
  • org-retroclock: Log CLOCK entries retrospectively without starting a timer (Reddit, Reddit)
  • Bringing micro-timers, checklist budgeting, and monotasking focus to Org-mode (org-focus-hud) (Reddit)
  • Sacha Chua: Des commandes vocales pour ajouter des tâches sur Emacs (YouTube, 02:44)
  • excali-mode 0.3.0: an Org-mode whiteboard inside Emacs (Reddit, HN, Reddit) - excali-board-mode: Org headings as cards; diagram DSL
  • Comparing org-roam, org-node, Supertag and vulpea, with a benchmark you can re-run
  • Org development:
    • ox-latex: safe and keyword for org-latex-table-scientific-notation
    • Enhance prefix argument to org-open-at-point on URLs
    • ox-latex: pass :align to table.el tables
    • Announce 'org-latex-listings-env'
• Coding:
  • What I use Eglot for in GNU Emacs and what good it is (@chris_siebenmann@robot.villas)
  • Magit Fast Mode [fast use magit]​ (Reddit)
  • Using Emacs for Javascript development - skewer-mode for evaluating CSS and HTML (@ArneBab@rollenspiel.social)
• Mail, news, and chat:
  • mu4e-send-later: A "Send Later" functionality for mu4e (Reddit)
  • aerc-mode: make it easier to use emacsclient within the aerc mail client (@PuercoPop)
• Multimedia:
  • supersonic.el Music Player v0.6.0 Update (added UPnP support) (Reddit)
• Multimedia:
  • Sacha Chua: Emacs Carnival Oct 2026: Exploring keys and voice input in Emacs
  • Sacha Chua: Using Emacs to visualize speaking and target words/phrases in real-ish time
• Fun:
  • # Emacs Golf #028 Rectangle Wizard
  • # Emacs Golf #026 We Only Need The First
  • # Emacs Golf #023 — Case-Insensitive Assassin
  • # Emacs Golf #011 Number Cruncher Category: B. Multi-line transformations
  • Emacs Golf: fixing misplaced spaces
  • 004BEGINNINGS THE CATTLE ARE LISPING lambdamoo moo.el VR puppets with common lisp emacs slime (@screwlisp@gamerplus.org)
  • 3D in MY Emacs!? (Hack and overview) (14:21)
• LLMs:
  • Emacs In the Age Of Magic / Rome Wasn't Built In A Day, More Like 10 Minutes (YouTube, 01:11)
  • M-x Machina — a workspace for coding agents inside Emacs (Reddit)
  • Voice AI Editing and an Emacs Plugin (01:33)
  • Emacs ollama agent compare (01:29)
  • Update: ecc 0.4, Claude Code in Emacs: Spaces and an agentic diff review (release notes, Reddit)
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-10-06 / week 40
  • Curtis McHale: Emacs Carnival - Will we change how we interact with Emacs? (Irreal)
  • Clojure Corner: Interview with Bozhidar Batsov (01:18:53)
  • I Asked Prot If I Should Switch to Emacs (13:02)
  • Protesilaos: Live: Ask me ANYTHING (2026-10-10 16:00 Europe/Athens) (5:04:50)
  • Accessing Reddit from Emacs will be impossible after November 13th - or use emacs-reddigg
• Other:
  • emacs-reader: Help wanted with testing PR #199 - Refactor rendering pipeline architecture to avoid race conditions and other multi-threading issues (@divyaranjan@mathstodon.xyz)
  • Tip about using negative prefix arguments (@lispwizard@techhub.social)
  • Sacha Chua: Emacs Lisp: Parse page ranges, insert issue references (Irreal, Irreal, Irreal)
  • New Emacs keepass package (Reddit)
  • Marcin Borkowski: Emacs Lock mode
  • A small change in xdisp.c reduced allocations by ~42% in a boxed-text workload
  • Configuring the Emacs UI for Better Latency and Perceived Responsiveness (Reddit)
  • Fixing the tree-sitter syntax highlighting bug in Emacs 31+ indirect buffers (The Emacs maintainers will not fix it, so I did) (Reddit)
  • Rust bindings for Emacs dynamic modules support canvas_data API (Reddit)
• Emacs development:
  • Fix/enhance prefix arguments to browse-url functions
  • Fix browse-url-chromium and browse-url-chrome NEW-WINDOW
  • Produce "!MEM FULL! " for %e in mode lines
  • Underline, overline, and strike-through can now be scaled with text.
  • New Tramp connection method "wslc"
  • * lisp/faces.el (header-line-emphasis): New face.
• New packages:
  • project-terminal: Per-project terminal management (MELPA)
  • org-timegrid: SVG week calendar with mouse and keyboard editing (MELPA)
  • markdown-ts-appear: Reveal Markdown source at point (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.

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

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

This evening I will do a live stream where I will continue developing the new denote-data feature for denote: it is an opt-in, in-memory cache with no dependencies that speeds up all sorts of operations.

I have made lots of improvements to it and it is already looking very promising, though I plan to develop it further and eventually write ert tests for it.

I will keep the chat on the side and shall respond to any questions about my programming but also any other issue (the other day I did a 5-hour live stream on the topic of “ask me anything” because my live streams tend to be that, anyway—recording here: https://protesilaos.com/codelog/2026-10-08-ask-me-anything-emacs-tech-politics-life/).

I came to realize that attempting to wrap up the “Wordcraft” section (as I call it) in Emacs is a fool’s errand. Emacs is Wordcraft. It’s what it’s all about. By the time I finish a draft, a new config or setting changes what I have. This here is an attempt to stay true to my conclusion in the last section.

Abbrevs

In my opinion, Abbrevs in Emacs is one of its fundamental features. It’s one of those things I’d show someone coming from other word-processing programs to show them the magic of Emacs. In essence, it’s a simple tool: you type two or more letters, and Emacs expands it to a phrase or even a whole paragraph. For example, when you type “hw” it will expand to “hello world” as soon as you hit space after the “w”.

Of course, you can achieve more with this useful function. We will get there. First, let’s discuss general usage:

• To add a new abbrev, stand with the marker after the abbreviation, and then use: C-x a g for a global abbrev (which applies everywhere in Emacs), or C-x a i l for the specific major mode of the buffer you’re in (so, if you’re working in shell inside Emacs, it will add an abbrev there specifically.)

• Once added, Emacs has a smart (and when you get it, helpful) way of remembering your lower-case/upper-case usage, depending on how you recorded the abbrev. Assume we’ve added “rnd” for “Research and Development”. This means:

  1. “rnd” automatically expands to Research and Development
  2. “Rnd” expands to Research and development (only the first word is capitalized!)
  3. “RND” expands to RESEARCH AND DEVELOPMENT

• You can escape abbrevs with C-q after typing the abbrev. If “rnd” expands to “Research and Development” but you actually want to type “rnd” in the buffer, type rnd followed by C-q¹.

• If you want to add a prefix to an abbrev, for example, you want the end result to be “non-Research and Development”, type: non- and then M-’ (this will result in a hyphen showing, which is good) and then rnd to produce the abbrev.

• Finally, don’t forget about edit-abbrevs which lets you edit your abbrev file directly. This is good when you want to add a bulk of abbreviations (I did this when I wanted to add usernames: I copy-pasted a bunch of those from Outlook one day during lunch).

Alright, with the basics out of the way, let’s dig into the config itself.

First, we want to turn on Emacs’ abbrevs. In my case, I want to put the abbrev file in a folder I sync between my computers so these shortcuts are available on both of them. To do this, I need to set the path for the abbrev file:

(setq-default abbrev-mode t)
(setq abbrev-file-name "~/Sync/Personal/.abbrev_defs")

Now something a bit more advanced. I posted about this before, but I didn’t explain my use case, and I think its usefulness is a bit lost as a result. Here’s the general idea.

At work, we have user IDs (usernames) that I need to use with ServiceNow, our ticketing system. It’s also useful when I want to write an email, and there are five people named “John.” My brain solved this problem years ago with nicknames: the John who has tattoos and a beard looks like a motorcyclist, so I call him Harley (Davidson); the other John loves tea from Georgia, so I call him George, etc.

When I want to dig out Harley’s username, I prefix it with @, and Emacs spits out “jd1234” for his username. This way I don’t hijack the word “Harley” to always be associated with jd1234, only when I really want to use it².

The post I linked above explains how this works and gives proper credit to Prot, who helped me build this up using regex:

(abbrev-table-put global-abbrev-table :regexp "\\(?:^\\|[\t\s]+\\)\\(?1:[@].*\\|.*\\)")
(abbrev-table-put org-mode-abbrev-table :regexp "\\(?:^\\|[\t\s]+\\)\\(?1:[@].*\\|.*\\)")

Grammar Checkers

When it comes to grammar, I explored two options in Emacs. I first started with LanguageTool, then discovered Harper, which I use today. But as these Emacs posts go, I need to take a step back and talk about spelling and grammar checkers first.

With a spell-checking tool, we just need a dictionary: a list of words the program checks against what we typed and identifies the closest match in its list. The mechanism behind it is a mathematical principle of edit distance: it is a fuzzy search for words that are the closest to the misspelled one³. This can be complemented with a personal dictionary of additional unofficial words that we tend to use, and that’s mostly it; we’re good to go.

A grammar checker is a different animal, or actually, animals. And before we start talking about these, it’s worth mentioning that grammar, or what is generally considered “correct” language, is a moving target⁴. Language is a grey area, where what’s correct can be — at least to a degree — subjective.

The complex mix of tools used in what we cram together today under the term “grammar checkers” is a big underestimation of the history and development of the last 50 years or so of progress and the different tools that we use today. With modern-day LLMs, the confusion extends further, as these usually don’t use any of those tools, relying only on transformers and weights to predict what seems correct and what isn’t⁵.

Harper

Many Emacs folks, myself included, use Harper these days. It’s no wonder, given its speed and minimal install size, especially compared with LanguageTool, the other free alternative. But this lightness comes at a cost.

Harper provides:

• a basic spelling checker (dictionary-based)
• core grammar rule engine

… and that’s it. Indeed, in my first post about Harper, I noted a couple of basic errors it missed, and I still think it’s far from “the private alternative to Grammarly,” as it states on its homepage. I actually barely use it because it’s the competition that does a much better job, grammar-wise. If it were up to me, the tagline would be “a private, fast, customizable grammar checker for when you don’t want a grammar nanny looking over your shoulder.”

Harper is available on homebrew (it seems the folks behind Harper made a dedicated dmg since I last installed it), but for Ubuntu and its kin, it requires Cargo. This also means that if Harper is the only program you have from Cargo, you also need to remember to update it⁶. I’ve written and explained my Harper setup a few times, but it evolved over time to accommodate both my Mac and my Linux desktop, so I’m including the whole thing here. Note that Harper works through Eglot on Emacs, as I explained in the first post linked above.

(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(org-mode . ("harper-ls" "--stdio")))) ; This is the eglot-related integration
(setq-default eglot-workspace-configuration
           '(:harper-ls (:dialect "American" :linters (:LongSentences :json-false :AvoidCurses :json-false))))
;; These are options for Harper. I chose American dialect as the language, I also want to ignore long sentence errors (the main issue is that it hides other errors nested in those) and I also want Harper not to tell me when it thinks something is offensive. The full list of these options is in https://writewithharper.com/docs/rules. It needs to be nested inside the :linters option.
(when (eq system-type 'gnu/linux)
  (add-to-list 'exec-path (expand-file-name "~/.cargo/bin"))
 (add-to-list 'exec-path "/snap/bin"))
;; On Linux, harper-ls lives in ~/.cargo/bin (installed via Cargo/Rust).
;; /snap/bin is added for Vale (installed via snap - that's another program I might discuss, ignore it for now) and any future snap packages.
;; On Mac, Harper is installed via Homebrew which handles PATH automatically.

LanguageTool

LanguageTool provides:

• A spelling checker
• Core rule Grammar engine
• n-gram data set (optional as local install for free)⁷
• LLM (Paid, online only)

In addition, as I was researching more into LanguageTool, I found lesser-known layers and additions that are not fully documented. For example, there’s a neural network for confusing pairs included. I don’t know how important those other tools are, but if you use the full product online to get a taste, you will see the difference when comparing it to Harper immediately.

While it sounds like I’m favoring LanguageTool over Harper, I don’t have it installed anymore, and I haven’t used it in a while. The reason for this is that it requires Java and over 10GB (yep) if you want to get the n-gram running with the other additions. Below is my old config, based on version 6.1. You will need to install langtool.el to run it, without the full layers discussed above (by the time I found out about these options, I stopped using it):

(require 'langtool)
(setq langtool-language-tool-server-jar "~/Path/To/Current/LanguageTool-#.#/languagetool-server.jar")
(setq langtool-default-language "en-US")

All in all, I do not think Emacs is the best place for grammar checkers. YMMV, but since I have access to Grammarly Pro’s features, I prefer it. I also use AI to go through my posts, and it does a few very useful things, grammar being just one of them if I need it to. If I didn’t have Grammarly, I’d consider LanguageTool’s pro package, which comes with additional perks that are not available for a local install.

My logic here is simple: if I write a post for my blog, which is going to be public anyway, I don’t mind using online tools or LLMs. For more sensitive things, like my journal, I use Harper if I want to, but most of the time it’s an overkill for my own mind’s rambling anyway. This is why I said above that I barely use Harper, as I don’t really have a use case for it.

I’m still under the weather: mostly I’ve been sleeping non-stop except for meals and bathroom breaks. That means that I’m still not up to producing a post with the usual Irreal wit and charm¹. I did have this post from Curtis McHale about the future of Emacs interaction in my TODO queue so I decided to do a quick write up about it.

McHale’s contention is that we use keyboards because they’re the best way of interfacing with computers. He points to everybody’s favorite keyboard replacement, voice input, but notes that even on Star Trek—that arguably popularized the idea—Captain Picard still tells his crew members where he wants to go and they type in the commands at their control stations.

As I said in my last post on the matter. my written thoughts are always much better organized than my verbal ones so moving to spoken input would be a net loss for me. Still, it will be interesting to see how things play out.

• 1. Introduction
• 2. TOC Container
• 3. JavaScript code for TOC generation
• 4. Styling the TOC using CSS
• 5. Does it work only in Blogger?

1. Introduction

Every now and then, I use Blogger as a personal system for publishing articles.

The articles are structured with sections and subsections and an initial table of contents.

The articles are mainly written in Org Mode using Emacs.

In this case, the table of contents is generated by the writing system itself during the conversion phase from Org Mode to HTML.

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.

Update (2026-10-11): A few people asked how neorepl relates to the Clojure CLI REPL, which the Clojure team released a couple of weeks ago, and to bb repl --connect. (I’m a bit embarrassed to admit I hadn’t heard of the former until after I announced neorepl.) Funny enough, all three are nREPL clients under the hood, but they’re after pretty different things. In practical terms:

• The Clojure CLI REPL runs only on the JVM and needs Clojure 1.12+. It ships its own nREPL server, and its docs and data inspector are ops of that server, so against any other server you can only evaluate code. It’s deps.edn only. Its editing is really nice, though - structural editing, evaluating the form at the cursor and a datafy-based inspector - and I’ll be borrowing some ideas from it. It doesn’t do completion yet.
• bb repl --connect puts babashka’s console REPL in front of any nREPL server, with completion, arglists and docs, in very little code. It’s a great way to poke at a running server, but it won’t start one for you.
• neorepl works with any nREPL server and gets the most out of the ones with cider-nrepl (or babashka’s take on it), without any middleware of its own. It starts a server for Leiningen, deps.edn, babashka and shadow-cljs projects, follows you into ClojureScript, and everything the REPL does is also a command with JSON output for scripts and agents. No structural editing yet, however.

So, if you want the fanciest line editing and you live in deps.edn land, give the Clojure CLI REPL a try. If you want CIDER in your terminal, for you and for your agents, that’s what neorepl is for. The neat part is that babashka’s server bundles CIDER’s inspector and test runner ops these days, so neorepl’s test runner (already on main) and the inspector that’s coming next work with babashka out of the box.

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=other"))
(defvar sacha-vad-tutor-events nil "List of events as an list of alists (label start stop duration).")
(defvar sacha-vad-tutor-labels '("sacha" "other"))
(defvar sacha-vad-tutor-summary '(("sacha" . 0)
                                  ("other" . 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)))

(defvar sacha-vad-event-handler-functions '(sacha-vad-speech-process) "Functions to call with the VAD/transcription events.")

(defvar sacha-vad-process-my-speech nil "Non-nil means process my speech through the whisper setup.")
(defun sacha-vad-speech-process (data)
  "Process DATA through my whisper input process if it's my speech.
Add to `sacha-vad-event-handler-functions'."
  (when (and sacha-vad-process-my-speech
             (string= (alist-get 'event data) "final")
             (string= (alist-get 'label data) sacha-vad-my-label))
    (with-current-buffer (get-buffer-create whisper--stdout-buffer-name)
      (erase-buffer)
      (insert (alist-get 'text data))
      (goto-char (point-min)))
    (whisper--handle-transcription-output nil (get-buffer-create whisper--stdout-buffer-name))))

(defun sacha-vad-tutor-filter (proc string)
  "Add and parse."
  (when (buffer-live-p (process-buffer proc))
    ;; split the string by newline?
    (let ((data (with-current-buffer (process-buffer proc)
                  (goto-char (point-max))
                  (save-excursion
                    (insert string))
                  (catch 'waiting
                    (unless (or (eobp) (looking-at "\n*$"))
                      (json-read))))))
      (run-hook-with-args 'sacha-vad-event-handler-functions data)
      (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.")

(defvar sacha-vad-transcript-buffer nil "If non-nil, add speech to this buffer.")
(defun sacha-vad-add-to-transcript (text)
  "Add TEXT to the transcript buffer."
  (when sacha-vad-transcript-buffer
    (with-current-buffer (get-buffer-create sacha-vad-transcript-buffer)
      (set (make-local-variable 'window-point-insertion-type) t)
      (save-excursion
        (goto-char (point-max))
        (insert text)))))

(defvar sacha-vad-my-label "sacha")
(defun sacha-vad-handle-text-event (data)
  (sacha-vad-add-to-transcript
   (concat
    (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-vad-my-label)
    (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)
                                  ("other" . 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))

See also:

• How to use abo-abo/tiny to expand "m47, 54|#%d"
• Inserting Number Ranges As A List | Irreal
• More On Number Ranges | Irreal
• Still More On Entering Ranges | Irreal

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 (Irreal)
  • 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.

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.