All my notes live in Denote, the fantastic Emacs package by Protesilaos Stavrou. The system is perfect while I am at the computer... but I wanted to read and edit my notes from my phone. I did not find anything that respected the Denote convention, so I built it myself: Dotdenote, an iOS app that reads, edits and creates notes following the Denote naming scheme over WebDAV. It is open source, you can browse the code at git.andros.dev/andros/dotdenote.

The app does not lock your notes anywhere: it talks to any WebDAV server, so they remain plain text files under your control. In this mini tutorial we will set up a WebDAV server with Docker, put an Nginx in front of it, and connect the app to your existing Denote notes. In less than 10 minutes you will be browsing your Zettelkasten from your phone.

What you need

• A machine to host the server: a home server, a Raspberry Pi, a VPS, or even your laptop.
• Docker with the Compose plugin installed. You don't need to use Docker, you can run the WebDAV server and Nginx directly on your machine, but Docker makes it easier to set up and maintain.
• Your Denote notes folder (.org, .md or .txt files).
• An iPhone with Dotdenote installed.

Step 1: Create the project structure

We will use hacdias/webdav, a small and solid WebDAV server, behind an Nginx reverse proxy. Both run as containers.

Create a folder for the stack and copy your notes inside data/notes/:

mkdir -p denote-server/data/notes
cd denote-server
cp -r ~/Documents/notes/* data/notes/

The notes subfolder is important: the app uses /notes/ as its default notes path, so this layout works out of the box.

Step 2: Configure the WebDAV server

Create config.yaml with the server settings and your credentials:

address: 0.0.0.0
port: 6065
directory: /data
permissions: CRUD
users:
  - username: denote
    password: change-me-please

A couple of notes:

• directory is the key used since v5 of hacdias/webdav (older tutorials mention scope, which no longer works).
• permissions: CRUD gives the user full read and write access, which is what the app needs to create and edit notes.

Step 3: Configure Nginx

Create nginx.conf. WebDAV uses HTTP methods and headers that a default proxy config does not forward, so we pass them explicitly:

server {
    listen 80;
    client_max_body_size 1g;

    location / {
        proxy_pass http://webdav:6065;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;

        # WebDAV specific headers. Destination arrives as an absolute URL,
        # rewrite it to a path so the backend accepts it.
        set $destination $http_destination;
        if ($destination ~ ^https?://[^/]+(/.*)$) {
            set $destination $1;
        }
        proxy_set_header Destination $destination;
        proxy_set_header Depth $http_depth;
        proxy_set_header Overwrite $http_overwrite;
    }
}

Step 4: The Compose file

Create compose.yaml gluing everything together:

services:
  webdav:
    image: hacdias/webdav:latest
    restart: unless-stopped
    volumes:
      - ./config.yaml:/config.yaml:ro
      - ./data:/data

  nginx:
    image: nginx:alpine
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - webdav

Your folder should now look like this:

denote-server/
├── compose.yaml
├── config.yaml
├── nginx.conf
└── data/
    └── notes/
        ├── 20240322T131856--my-note-title__emacs_notes.org
        └── ...

Start it:

docker compose up -d

Step 5: Test the server

The app checks the connection with a PROPFIND request, so let's do exactly the same with curl (replace the IP with the address of your server):

curl -u denote:change-me-please -X PROPFIND -H 'Depth: 1' http://192.168.1.50:8080/notes/

If you get an XML response listing your notes, the server is ready. If you get a 401, check the credentials in config.yaml; if you get a 404, check that your notes live inside data/notes/.

Step 6: Connect the app

Download Dotdenote from the App Store: https://apps.apple.com/us/app/dotdenote/id6773266542

Open the app and fill in the setup form:

Tap [ test connection ]. When you see the check mark, save, and your Denote notes will appear in the list: you can search them, open them, edit them, and create new ones. Every note the app creates follows the Denote convention (IDENTIFIER--title__keywords.ext) with the proper front matter for Org, Markdown or plain text, so everything stays perfectly compatible with Emacs.

The password is stored in the iOS Keychain, and the notes never touch any third-party service: the app only talks to your server.

Optional: expose it to the internet

The setup above is fine inside your home network or over a VPN like WireGuard or Tailscale. If you want to reach your notes from anywhere, do not expose plain HTTP: put a domain in front of the server and add TLS. The quickest path is to run Nginx on the host (or use a proxy like Caddy or Traefik) with a Let's Encrypt certificate from Certbot, pointing to 127.0.0.1:8080. Then use https://notes.example.com as the URL in the app, everything else stays the same.

Enjoy it!

Some time ago, I installed Embark but I never got around to learning it and it has sat unused ever since. Then I saw this post by Bozhidar Batsov and decided to take another look. The problem with Embark is that it’s hard to understand and the documentation is long and complex. Too long, I discovered, to read and understand in one sitting.

I approached the problem by reading a section at a time and trying out examples in my Emacs. Even so, it still took some experimentation to completely figure things out. The process is ongoing but I’m making progress.

All of the above sounds pretty negative but I actually think Embark is a real win. Once you figure things out it’s really useful. For example, one of the things I’ve never been able to get working reliably is following a link in an arbitrary buffer to its target. Embark does that easily and if you use embark-dwim it’s a single keystroke. I use Hyper+. for embark-act and Hyper+, for embark-dwim. I have Hyper bound to the right ⌘ Cmd key so it’s very easy to invoke either of those commands.

Batsov is all in on Embark. He and I often share preferences and this is an example of that. The more I find out about Embark, the more I like it. The commands that work on a group of files can be difficult to grok but once you do they’re very powerful. I’ve resigned myself that learning Embark is an ongoing process but I think it’s worth it.

Nous allons parler en direct avec Richard Bonichon (Github) d'Emacs, de ses flux de travail, de sa configuration, et d'autres sujets en français. Je suis un peu intimidée, mais si vous posez vos questions dans le chat, je pense que nous pouvons survivre à mon faible niveau de français. =)

Notes : https://sachachua.com/blog/2026/08/le-6-aout-emacs-chat-richard-bonichon/

La diffusion en direct aura lieu le [2026-08-06 Thu 07:30]–[2026-08-06 Thu 08:30] dans le fuseau horaire America/Toronto, soit 0730H EDT / 0630H CDT / 0530H MDT / 0430H PDT / 1130H UTC / 1330H CEST / 1430H EEST / 1700H IST / 1930H +08 / 2030H JST.

Si vous voulez parler d'Emacs avec Prot et moi en français, n'hésitez pas à m'envoyer un courriel !

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

Nous allons parler en direct avec Abdallah Maouche (heiwiper) (Gitlab, Github) d'Emacs, de ses flux de travail, de sa configuration, et d'autres sujets en français. Je suis un peu intimidée, mais si vous posez vos questions dans le chat, je pense que nous pouvons survivre à mon faible niveau de français. =)

La diffusion en direct aura lieu le [2026-08-20 Thu 07:30]–[2026-08-20 Thu 08:30] dans le fuseau horaire America/Toronto, soit 0730H EDT / 0630H CDT / 0530H MDT / 0430H PDT / 1130H UTC / 1330H CEST / 1430H EEST / 1700H IST / 1930H +08 / 2030H JST

Si vous voulez parler d'Emacs avec Prot et moi en français, n'hésitez pas à m'envoyer un courriel !

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

which-key is one of those packages I recommend to pretty much everyone - newcomers and grizzled Emacs veterans alike. You start a key sequence like C-x, pause for a moment, and it pops up a handy cheat sheet of every key that can follow. I’ve had it in my config for ages, and I suspect a lot of you have as well.

Here’s the good news - as of Emacs 30 you don’t need to install it anymore. which-key is now a built-in package, so there’s one less thing to fetch from MELPA when you set up Emacs on a fresh machine.

Enabling which-key

Being built-in doesn’t mean it’s enabled by default, though. You still have to turn it on explicitly:

(which-key-mode 1)

That’s the whole setup for most people. Now start any prefix key - C-x, C-c, C-h - wait a moment, and a popup appears at the bottom of the frame listing every binding under that prefix.

Here’s what I get when I press C-c p, the prefix for projectile’s command map:

Instead of straining to remember whether it’s C-c p f or C-c p s s, I just pause and Emacs reminds me. Projectile has a lot of commands, so which-key even paginates them - notice the 1 of 3 in the bottom corner.

Configuration

The defaults are sensible, but here are the knobs I reach for most often:

;; show the popup faster (the default is a full second)
(setq which-key-idle-delay 0.5)

;; where the popup shows up
;; options: side-window (default), minibuffer, frame, custom
(setq which-key-popup-type 'side-window)

;; and where that side window sits
;; options: bottom (default), top, left, right
(setq which-key-side-window-location 'bottom)

I like a slightly snappier delay, but otherwise the stock configuration serves me just fine.

which-key and Transient

People sometimes ask me how which-key relates to Transient - the menu library that powers Magit’s famous popups. The two look superficially similar (both drop a bunch of keys and descriptions at the bottom of your frame), but they solve rather different problems.

which-key is a passive, automatic reminder. It doesn’t really know anything about your commands - it simply reads whatever keymap you happen to be in and shows you what’s there. You get it for free, across every prefix in Emacs, with zero per-keymap work.

Transient is an interactive command builder. You design a transient deliberately, for a particular workflow, and unlike which-key it can hold state

• toggle switches on and off, accumulate arguments - before finally running a command with all of that baggage attached.

Projectile happens to ship both, which makes for a nice side-by-side. The C-c p keymap you saw above is a plain keymap - which-key displays it and then gets out of the way. But Projectile 3.0 also added projectile-dispatch (bound to C-c p m), a Transient menu that mirrors the very same command map:

Notice the Modifiers section at the top - those are switches you flip before picking a command. Want your next search to be case-sensitive, or your next file lookup to invalidate the cache first? Toggle -c or -i, then press the command key. That’s something a plain keymap (and therefore which-key) simply can’t do.

So the way I see it - reach for which-key as an always-on safety net for the thousands of bindings scattered across Emacs, and reach for Transient when you’re building a polished, self-contained command center for a specific task. They’re complementary, and there’s no reason not to run both. In fact, if you use Magit or Projectile (or a dozen other modern packages), you’re already using Transient whether you realized it or not.

But wait, what about C-h?

Long-time Emacs users might point out that you’ve always been able to press C-h after a prefix key to see the available bindings. That’s true! The difference is that which-key does it automatically, no extra keypress required - which makes it far more discoverable, especially for newcomers.

And the two don’t step on each other. C-h after a prefix still works and gives you the traditional describe-bindings buffer, which you can scroll and search to your heart’s content. Think of which-key as the quick glance and C-h as the full reference.

Closing Thoughts

I’ve been a happy which-key user for years, and having it in the box means one less package to install and keep updated. If you’ve somehow never tried it, do yourself a favor and flip it on - it’s the kind of small quality-of-life feature you stop noticing precisely because it’s always quietly helping you.

Do you keep which-key on all the time, or do you prefer to lean on C-h? And have you started building your own Transient menus yet? I’d love to hear about it in the comments.

That’s all I have for you today. Keep hacking (and let Emacs remember the keys for you)!

Sayid 0.8 is out! It’s the third release since I brought Sayid back from the dead a couple of weeks ago, and it has a clear theme: making the tool easy to pick up. The revival releases were mostly about the engine - bounding the recording, consolidating the API, getting the data out. This one is about the experience. If you’ve ever bounced off Sayid because you couldn’t figure out what to press, or what it was trying to tell you, 0.8 is for you.

It started with a bug report

Shortly after the revival post, someone reported that pressing c i in the workspace view - “inspect this captured value” - printed Def'd as $s/* and then… nothing. The fix turned out to be a one-liner: Sayid was calling a CIDER function whose signature changed years ago, and nobody had noticed since. Which tells you everything about how many people were actually using that command.¹

The one-liner was easy, but the report got under my skin. If the inspector integration could sit broken for years, what else about Sayid was quietly hostile to anyone trying it for the first time? So I sat down and did a proper UX audit of the Emacs client, wrote down everything that made me wince, and 0.8 is the result.

Here’s the current state of affairs in one take - trace, run, explore:

Catching up: 0.6 and 0.7

Before we get to the UX work, a quick recap of the two releases I never got around to announcing (the revival post covered things up to 0.5).

Sayid 0.6 rebuilt inner tracing - the mode that records every intermediate expression inside a function - on top of tools.analyzer.jvm. The old implementation re-read your source and rewrote raw forms, with special cases for individual macros; the new one works off the analyzed AST. That killed the long-standing bug where an inner-traced try/catch would swallow exceptions, along with the per-macro special-casing that made the old instrumenter so fragile.

Sayid 0.7 made the trace itself data. sayid.data/trace-data returns the recorded call tree as plain Clojure data with the live captured values, and tap-trace! sends it to tap>, so you can explore a recording in Portal or your data tool of choice. It also added sayid.golden - capture a run’s call tree as a baseline, then assert future runs still match it, which is a surprisingly pleasant way to pin down the behavior of gnarly legacy code before refactoring it.

The highlights

Now, the 0.8 goodies. The full list is in the changelog, but here’s what I’m most excited about:

• There’s a proper entry point now: C-c s pops up a transient menu (sayid-menu) that groups the commands along Sayid’s core loop - trace something, run your code, explore the recording - and shows you how much is traced and recorded right now, or what’s missing (a REPL, the middleware) when you’re not connected. The menu uses the same key sequences as the classic prefix map, so your muscle memory keeps working, and sayid-use-menu brings the plain keymap back if popups aren’t your thing.

• sayid-trace-fn (C-c s t t) is the new “just trace this” command. You no longer need to know what inner and outer traces are before you can trace your first function - the default does the right thing, and you can graduate to the fancier variants later.
• Empty views teach instead of scolding. Opening the workspace before anything was recorded used to greet you with an error; now you get the buffer anyway, with a short walkthrough of how to get data into it. The first five minutes with Sayid should no longer require reading the manual.
• The commands talk back like a human. Tracing a function now tells you what happened and what to do next (“Outer-traced acme.checkout/subtotal - run some code, then C-c s w shows what was recorded”), and trying to enable a trace that doesn’t exist tells you the actual problem instead of pretending everything went fine.
• The workspace tree is now the one view to rule them all: on any call you can inspect a captured value in CIDER’s inspector (c i - yes, it works now), def it to a var for REPL poking (c d), pretty-print it (c p), or copy an expression that reproduces the call (c r). C-c s f - show the recorded calls of the form at point - renders there too.
• A pile of small courtesies that add up: tracing a function no longer steals your window with a popup, g refreshes the Sayid buffers like every other Emacs buffer, and resetting the workspace asks before irreversibly dropping your traces and recording.
• The client and the middleware now tolerate version skew - if your deps.edn pins an older Sayid jar than your Emacs package expects, things degrade politely instead of erroring in strange ways.
• The Emacs client now requires CIDER 2.0, which let me drop a bunch of compatibility shims and lean on the new cider-tree-view throughout.
• And the README finally shows the tool instead of just describing it - screenshots and the GIF above included. A picture of a call tree is worth a thousand words about one.

Upgrading notes

Nothing here should break a working setup, but two things are worth knowing. The Emacs package now requires CIDER 2.0 (released earlier this week), so they’ll need to be upgraded together. And C-c s now opens the menu instead of acting as a bare prefix - every old key sequence still works exactly as typed, but if you prefer the old silent prefix, set sayid-use-menu to nil. A few commands got more consistent names (sayid-trace-fn-outer and friends); the old names live on as obsolete aliases.

Onward

When I wrote the revival post I asked people to kick the tyres and tell me what feels rough. This release is what acting on that feedback looks like, and it’s exactly the kind of contribution I need more of - a two-line bug report turned into the biggest usability overhaul in the project’s history. So thanks to everyone who has been trying out the revived Sayid, and please keep the reports coming on the issue tracker.

[mx.cider/sayid "0.8.0"] is on Clojars, the Emacs package is on MELPA, and tracing your first function is now a single C-c s t t away. Give it a spin!

Keep hacking!

Projectile 3.2 is out!¹ That’s the third Projectile release this month, and by now you probably see the pattern - a whole lot of nothing for a couple of years, then everything at once. Where 3.0 was the big cleanup and 3.1 the pile of long-standing feature requests, 3.2 is a focused release with one clear theme: search and replace. Plus one bonus feature I’ve wanted for ages, but more on that below.

Replace, but with a preview

projectile-replace has always been one of those commands that technically worked, but that I never quite trusted. It walks the project file by file with query-replace, asking you about every match with no way to see the big picture, and once you start there’s no graceful way out. I’ve been promising myself a better story there for years (that’s #1924, if you’re keeping score at home).

3.2 finally delivers it. projectile-replace-review (s-p R) prompts for a search string and a replacement, gathers every match across the project into a *projectile-replace* buffer, and shows you a per-match preview of exactly what’s about to change. Every match can be toggled on or off, and ! applies just the enabled ones - in any order, whenever you’re ready. Here’s the whole flow, start to finish:

The matches are gathered in Emacs Lisp rather than by shelling out to grep, so projectile-replace-regexp-review honours full Emacs regexp syntax (yes, including \_<foo\_> and capture groups in the replacement), and the preview reflects the exact text that will be edited - including unsaved changes in buffers you already have open. The apply step is equally paranoid: files are edited bottom-up so earlier edits can’t shift later matches, open buffers get a single undo step, and buffers modified since the scan are skipped rather than clobbered.

The results buffer is a little workbench of its own - you can toggle case sensitivity (c), flip between literal and regexp matching (x), keep or flush matches by line or by file (k/d/K/D), and export everything to a grep-mode buffer (e) if you’d rather finish the job with wgrep. And both reviewers scan the project asynchronously, so a big search no longer freezes Emacs - matches stream in as they’re found and you can bail out at any point.

Search gets the same treatment

Once the replace reviewer existed, the obvious next question was “can I have this without the replacing part?”. You can. projectile-search-review (s-p s R) collects every match for a term into a read-only *projectile-search* buffer, grouped by file, with the matched spans highlighted:

It shares the replace reviewer’s navigation and filtering, and pressing r hands the current search over to the replace reviewer, carrying along the term and settings and prompting only for the replacement. So “look first, replace later” is now a single keystroke, not a re-do.

My favourite touch: when rg is installed, a literal search rides ripgrep and streams matches in near-instantly even on huge projects (customizable via projectile-search-use-ripgrep). The regexp variant and the replace reviewer always use the portable Emacs Lisp scan, so the preview you act on is always the real thing.

A tab per project

The bonus feature: projectile-session-mode, a global minor mode that gives each project its own tab-bar tab. Switch to a project and Projectile either selects its existing tab (with the window layout you left there) or opens a fresh one named after the project. Sessions can also persist across restarts - s-p w s saves a project’s layout and buffers, switching to the project can restore it automatically, and projectile-session-restore-all brings your whole working set back after a restart, each project in its own tab.

I’ve long envied the “workspace per project” workflows people build with tab-bar and a handful of hooks, and now Projectile just does it out of the box. It’s opt-in, so nothing changes unless you enable the mode.

Odds and ends

A few smaller things that shipped alongside the headliners:

• The reviewable search/replace learned whole-word matching - toggle it with w in the results buffer, or default it with projectile-search-whole-word.
• projectile-dispatch picked up matching switches - --word and --case-sensitive seed the reviewable search/replace, the same way --regexp already did for the other search commands.
• All the search prompts now share one consistent format that shows the tool that will actually run and the symbol-at-point default up front. No more guessing whether you’re about to invoke grep or ripgrep.
• Projectile’s prompts now advertise the right completion metadata category per command, so marginalia annotates candidates properly (buffers get buffer annotations, projects get file ones) and embark can act on them. With vertico and marginalia the built-in commands look downright fancy now:

• Function-valued lifecycle commands (say, a CMake preset picker) are re-invoked on every run instead of having their first result frozen in the command cache - an old gotcha that bit CMake users in particular.

Wrapping up

No breaking changes this time, and nothing to migrate - the full list of changes is in the changelog, as always.

More importantly, 3.2 completes - for now - the arc I embarked on with 3.0. Looking back at the whole 3.x series, the mission boils down to three things:

• make Projectile’s internals faster, simpler and more robust
• modernize the UX (async everything, the dispatch menu, and now reviewable search and replace) and give people more reasons to prefer Projectile
• replace hardcoded behavior with mechanisms - backend registries, file kinds, named tasks, session serializers - that you can bend to your own workflow in a few lines of config

All three boxes feel properly ticked at this point, so the summer release burst is probably winding down.² Projectile is in the best shape it’s been in years, and I’m having more fun working on it than I’ve had in a long time. Huge thanks to everyone who reported issues and tested the new reviewers while they were taking shape!

Keep hacking!

When you write a tree-sitter major mode, it’s tempting to think the parser handles everything. It doesn’t. Tree-sitter drives font-lock, indentation, and structural navigation, but a whole layer of everyday Emacs behavior still runs on the humble syntax table: forward-sexp and friends, electric-pair-mode, delete-pair, forward-word, and anything built on syntax-ppss. (I wrote about that structural layer in Essential Structured Navigation and Editing Commands.)

I got a sharp reminder of this while building neocaml, my tree-sitter mode for OCaml. The grammar parsed everything beautifully, yet delete-pair and sexp motion kept misbehaving around a couple of OCaml constructs. The fix turned out to be a classic tool that long predates tree-sitter: syntax-propertize-function. Here’s the story - it tripped me up for a good while, so maybe it’ll spare you some head-scratching.

The problem: characters a static syntax table can’t classify

A syntax table assigns each character a single class: this one opens a string, that one is a comment starter, this is a word constituent. That works until a character means different things in different places. OCaml has two such troublemakers.

Character literals. 'a' is a character, and the single quotes delimit it. But the same ' also starts a type variable ('a in 'a list), and can appear inside identifiers as a prime (x'). So you can’t just declare ' a string delimiter. And if you leave it as a symbol constituent (the usual choice), a character literal whose contents happen to be a delimiter wreaks havoc:

let x = '"'   (* the " opens a string, as far as the syntax table knows *)
let y = '('   (* the ( is an unbalanced open paren *)

Quoted string literals. OCaml’s {|...|} (and tagged {foo|...|foo}) raw strings can contain anything - including ", (*, and friends - which the syntax table reads as real string/comment delimiters:

let z = {|a "b" (* not a comment *)|}

You can see the damage with syntax-ppss. With nothing but a static table, point at the end of let x = '"' reports that you’re inside a string:

(nth 3 (syntax-ppss))  ;; => 34   (i.e. inside a string opened by ")

And every command that consults the syntax table inherits the confusion: C-M-f walks off into nonsense, delete-pair grabs the wrong delimiter, electric-pair-mode autopairs incorrectly.

Note that font-lock looks fine here - tree-sitter fontifies these constructs correctly from the parse tree. That’s exactly what makes the bug sneaky: the buffer looks right, but the syntactic layer underneath is lying.

The fix: context-sensitive syntax with syntax-propertize

The escape hatch is syntax-propertize-function: a buffer-local function that runs lazily over regions of the buffer and applies syntax-table text properties to override the static table where context demands it. Because the properties are attached to specific positions, ' can be a string delimiter in 'a' and an ordinary symbol character in 'a list - in the same buffer.

The usual way to write one is with syntax-propertize-rules, which maps regexps to the syntax classes to apply to their capture groups. Here’s the heart of neocaml’s:

(defun neocaml--syntax-propertize (start end)
  (goto-char start)
  (funcall
   (syntax-propertize-rules
    ;; Character literals: 'a', '\n', '"', '(', ...
    ;; Mark both quotes as string delimiters so the contents are inert.
    ;; A closing quote is required, so type variables ('a) are untouched.
    ("\\_<\\('\\)\\(?:[^'\\\n]\\|\\\\.[^\\'\n \")]*\\)\\('\\)"
     (1 "\"") (2 "\""))
    ;; Quoted strings {tag|...|tag}: fence both ends so the body is inert.
    ("\\({\\)\\([[:lower:]_]*\\)|"
     (1 (let* ((tag (match-string 2))
               (close (save-excursion
                        (when (search-forward (concat "|" tag "}") end t)
                          (point)))))
          (when close
            (put-text-property (1- close) close
                               'syntax-table (string-to-syntax "|")))
          (string-to-syntax "|")))))
   (point) end))

and you install it in the mode body:

(setq-local syntax-propertize-function #'neocaml--syntax-propertize)

Two kinds of rules are at work:

• The character literal rule matches a complete '...' and gives both quotes string-quote syntax ("). The contents then sit inside a string as far as the scanner is concerned, so an inner " or ( is inert. Crucially, the regexp requires a closing quote, so a bare 'a type variable never matches and keeps its symbol syntax.
• The quoted string rule matches the opening {tag|, searches for the matching |tag}, and marks both the opening and closing delimiters with generic string fence syntax (|). Everything between two fences is a string, so embedded quotes and comment starters are neutralized.

With that in place, syntax-ppss tells the truth again, and C-M-f, delete-pair, and electric-pair-mode all behave - including for the delete-pair corner case I wrote about earlier.

Lessons for mode writers

A few things worth keeping in mind, whether or not you touch OCaml:

• Tree-sitter and the syntax table are different layers. The parser handles font-lock and structural queries, while the syntax table handles character-level motion and pairing. A great grammar doesn’t save you from getting the syntax table right. (See also Customizing Font-Lock in the Age of Tree-sitter.)
• Reach for syntax-propertize whenever a character’s role depends on context - raw strings, here-docs, regex literals, character literals, JSX, anything a single syntax class can’t capture. It’s exactly what rust-ts-mode and c-ts-mode reach for, too.
• The syntax-table text properties don’t affect tree-sitter font-lock. They live on a separate channel, so you can fix the syntactic layer without disturbing your carefully tuned highlighting.
• Don’t call syntax-ppss from inside your syntax-propertize-function. It’s re-entrant (syntax-propertize is itself driven by syntax-ppss) and a fragile source of subtle bugs. Match constructs whole from their opening delimiter instead, as the quoted-string rule above does, rather than asking “am I currently inside a string?”.
• Know your string classes. Class " (string quote) is delimited by the same character, while class | (generic string fence) pairs up independently of the specific character. The latter is handy for multi-character or asymmetric delimiters like {tag| … |tag}.

None of this is new - syntax-propertize has been the right answer since Emacs 24. But it’s easy to forget it exists when you’re deep in tree-sitter land, and the symptoms (movement and pairing going subtly wrong while the colors look perfect) are puzzling until you remember which layer owns what.

Have you run into this while writing your own tree-sitter modes? I’d love to hear how you tamed the syntax table in the comments.

That’s all I have for you today. Keep those parens balanced!

As part of the ongoing overhaul of my Emacs setup I’ve been trying to make the most of the built-in functionality that recent Emacs releases keep quietly shipping. My in-buffer completion setup is based on corfu and cape these days, but it turns out I had overlooked a nice Emacs 30 addition in the same area - completion-preview-mode. It gives you inline completion suggestions - the “ghost text” UI that GitHub Copilot and friends made famous¹ - except here it’s powered by plain old Emacs completions.

What It Does

As you type, completion-preview-mode shows a grayed-out preview of the top completion candidate right after point - inline, in the buffer itself. No popup, no minibuffer, no fuss. If the suggestion is what you want, press TAB to accept it. If not, just keep typing and the preview updates (or goes away).

The part I like best - the candidates come from completion-at-point-functions, which means the preview is fed by the exact same backends as corfu and company. If you’ve already set up cape-dabbrev, cape-file or eglot, all of them power the ghost text automatically. Batteries very much included.

Enabling It

You can try it out in the current buffer with M-x completion-preview-mode. If you like what you see, you can enable it everywhere:

(global-completion-preview-mode 1)

Here’s the relevant bit of my config:

(use-package completion-preview
  :ensure nil ; built-in
  :config
  ;; cycle through the other candidates with M-n/M-p (those two
  ;; commands have no default bindings)
  (define-key completion-preview-active-mode-map (kbd "M-n") #'completion-preview-next-candidate)
  (define-key completion-preview-active-mode-map (kbd "M-p") #'completion-preview-prev-candidate)
  (global-completion-preview-mode +1))

Essential Keybindings

While a preview is visible you can make use of the following keybindings:

• TAB (completion-preview-insert) - accept the suggested completion
• M-i (completion-preview-complete) - insert only the longest common prefix of all the candidates (the preview underlines it, so you know in advance what you’ll get) and let you keep typing from there
• M-n / M-p (completion-preview-next-candidate / completion-preview-prev-candidate) - cycle through the other candidates; those are not bound by default, but the docs themselves suggest M-n and M-p (see my config above)

Here’s M-i in action. I had typed my-pro, and pressing M-i filled in ject-find-, stopping exactly where the two candidates (my-project-find-file and my-project-find-dir) diverge:

And when you cycle with M-n, Emacs even tells you where you are in the candidate list in the echo area:

There’s basic mouse support as well - clicking the ghost text with mouse-1 inserts it, and scrolling the mouse wheel over it cycles through the candidates. (I doubt I’ll ever use that, but it’s kind of cute)

Fine-tuning

A few user options to adjust the behavior:²

;; show the preview only after typing at least 3 characters (the default)
(setopt completion-preview-minimum-symbol-length 3)

;; wait a bit before showing the preview (by default it shows up instantly)
(setopt completion-preview-idle-delay 0.2)

;; show a preview only when there's exactly one candidate
(setopt completion-preview-exact-match-only t)

There’s also completion-preview-commands - the list of commands after which the preview appears (things like self-insert-command). You’ll rarely need to touch it, but it’s good to know it’s there if some command you use doesn’t trigger the preview.

Do You Still Need Corfu?

When I first read about completion-preview-mode I assumed it was competing with corfu and company, but I’ve come to think that’s the wrong way to look at it. They draw candidates from the same source and simply present them differently - corfu gives you the full candidate list with annotations and documentation, while the preview gives you the single most likely candidate with zero visual ceremony. These days I run both: the ghost text handles the “obviously I meant that symbol” cases with a single TAB, and corfu’s popup kicks in when I actually need to browse.

Admittedly, two completion UIs at once won’t be everyone’s cup of tea. If you find it too busy, a nice middle ground is to enable completion-preview-mode only where a popup feels out of place - e.g. in eshell-mode or comint-mode buffers.

Closing Thoughts

Emacs 30 keeps chipping away at my list of third-party packages - which-key and EditorConfig support are now built-in, and completion-preview-mode covers a niche I didn’t even know I wanted covered. Not bad for a “boring” stable release!

Have you tried completion-preview-mode already? Are you a ghost text person or a popup person? (or both, like me) I’d love to hear your thoughts in the comments!

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

This is another installment in the series of articles about the notable changes in CIDER 2.0. Today’s topic is one of those “ambitious ideas that lay dormant for ages” I keep mentioning: proper interactive macro stepping.

The Dream

CIDER has had macroexpansion support practically forever - C-c C-m expands the form before point into a dedicated buffer, a feature we inherited spiritually from SLIME. It works, but it has always felt a bit… detached. The expansion lives in another buffer, divorced from the code you’re reading, and for deeply nested macros you end up bouncing between buffers trying to keep your bearings.

Emacs Lisp hackers have long had something nicer: macrostep, a brilliant little package that expands macros in place - right where they sit in your code - one step at a time, and collapses them back when you’re done. I’ve wanted a Clojure version of this for years. CIDER 2.0 finally ships one.

Standing on shoulders, not on top of them

I’m hardly the first person to want this. The idea of bridging CIDER and macrostep goes back to at least 2016, where a proof of concept wired up macrostep’s extension hooks to CIDER by injecting a couple of helper functions into your REPL and shuttling forms back and forth as strings. Later, macrostep-geiser - a Scheme-oriented macrostep backend - grew CIDER support as well, and SLIME itself ships a slime-macrostep contrib built on the same extension API. So the hooks were there, the hacks existed, and I could have blessed one of them and called it a day.

I opted for a clean, from-scratch implementation in CIDER instead - mostly to provide the best possible experience for Clojure programmers, without the compromises the bridges had to make. macrostep’s extension API was designed around Emacs Lisp’s happy circumstances, and Clojure violates most of them:

• macrostep-expand-1-function must be synchronous. That’s fine when expansion is an elisp function call; it’s less fine when it’s a network round-trip to an nREPL server. (CIDER has been busy removing exactly this kind of blocking call lately - asynchronous eldoc being the poster child.)
• The API traffics in forms - elisp data structures. But Clojure code isn’t elisp data: keywords, reader tags, #() lambdas and namespaced maps have no faithful elisp representation, so every bridge ends up round-tripping code through strings and hoping the quoting survives. The 2016 proof of concept literally did (format "(expand-once '%s)" form), which should make anyone a little nervous.
• macrostep-print-function expects the client to print and fontify the expansion. In CIDER the server does the printing - that’s how we get namespace tidying (when instead of clojure.core/when), print-option handling and metadata display for free. A client-side printer would have to reimplement all of that, badly.

There’s also a less technical reason: lately I’ve grown rather averse to adding third-party dependencies to CIDER. A dependency is a bet on someone else’s continued enthusiasm, and such bets sometimes go bad - tellingly, macrostep itself spent a stretch unmaintained and now lives in a GitHub org literally named “emacsorphanage” (it has since found a new maintainer, but the point stands). CIDER is 14 years old and intends to stick around; over that kind of horizon, owning ~600 lines of overlay code is cheaper than adopting someone else’s semi-abandoned package. So we kept macrostep’s brilliant UX ideas and its familiar keybindings, and left the coupling behind.

cider-macrostep

The entry point is cider-macrostep-expand (C-c M-m e). Put point after a macro form, invoke it, and the form is replaced inline with its one-step expansion, highlighted so you can tell what’s expansion and what’s your code:

(when-let [x (fetch-thing)]
  (process x))

;; C-c M-m e =>

(let [temp__5825__auto__ (fetch-thing)]
  (when temp__5825__auto__
    (let [x temp__5825__auto__]
      (process x))))

From there you’re in cider-macrostep-mode, where the further-expandable sub-forms are underlined, n/p hop between them, e (or RET) steps into one, and c/q collapse one level or everything back to the original code. Your buffer is never actually modified in a way that sticks - collapse everything and it’s exactly as it was.

Here’s the whole flow in motion - expand, step into a nested macro, collapse back to the original code:

A couple of touches I’m particularly fond of:

• Every distinct gensym in the expansion gets its own color, so you can finally track where that temp__5825__auto__ flows through the expanded code. Once you’ve seen a for expansion with colorized gensyms, you won’t want to go back:

• E (cider-macrostep-expand-all) fully expands the form in one step, for when you don’t care about the journey.
• b (cider-macrostep-expand-in-buffer) runs the same stepping session in a dedicated popup, leaving the source buffer untouched - handy when you’re in someone else’s code and feel uneasy about inline rewrites, however temporary.

The classic buffer got some love too

The traditional macroexpansion buffer wasn’t neglected either: it grew a header line showing the active expander and display options, n and t cycle namespace display and metadata in place, g re-expands with the latest macro definition, and freshly expanded forms pulse briefly so your eye lands in the right place.

The expansion commands also got more talkative: pointing them at an unresolved symbol now tells you whether the namespace simply isn’t loaded yet (evaluate the buffer!) or you’ve got a typo, instead of silently doing nothing.¹

Why bother?

Macros are the part of Clojure people are most likely to describe as “magic”, and the standard advice - “just macroexpand it” - has always carried a hidden tax: the expansion of any non-trivial macro is a wall of gensyms and nested let*s that’s genuinely hard to read cold. Stepping through the expansion one level at a time, in place, with the gensyms color-coded, turns that wall into something you can actually follow. I did not expect macro debugging to become fun, and yet here we are.

All the details are in the macroexpansion docs. Give it a try the next time a macro surprises you - and keep hacking!

Hot on the heels of CIDER 2.0, clj-refactor.el 4.0 is out! It’s the first major release of the project in almost five years, and this time around the version bump is not just ceremonial - 4.0 is the biggest batch of user-facing improvements clj-refactor has seen in ages, plus a healthy dose of long-overdue spring cleaning.

Unfinished business

When I announced clj-refactor.el 3.0 back in 2021, I opened with a confession - we had failed to deliver the main objective of that release, namely restoring the dependency hot-loading that JDK 9’s module system broke. Well, better late than never: cljr-hotload-dependency is back in 4.0, reimplemented on top of clojure.tools.deps, and it even accepts deps.edn-style coordinate maps alongside the classic Leiningen vectors.¹

I’ll also be honest about the bigger picture, as I was back then: clj-refactor spent most of the intervening years in maintenance mode, while clojure-lsp became the default refactoring engine for much of the community. That hasn’t discouraged me, though - it clarified what clj-refactor should be. The project now has a proper roadmap that spells out where things are headed (spoiler: a static analysis index and closer ties with CIDER), and 4.0 is the first big step in that direction.

The highlights

The changelog for 4.0 has over 40 entries, but here’s what I’m most excited about:

• There’s a new clj-refactor-menu - a transient menu of every command, grouped by category (bound to hh under your prefix, e.g. C-c C-m hh). It mirrors the classic two-letter mnemonics, so it doubles as a way to finally learn them. It replaces the old hydra-powered menus, which allowed us to drop the hydra dependency.
• Project-wide refactorings are no longer a leap of faith. cljr-rename-symbol, cljr-change-function-signature and cljr-inline-symbol now show you their edits as a diff and touch nothing until you confirm, and the new cljr-undo-last-refactoring (ur) reverts the last applied refactoring across every affected file in one step.
• The heavyweight commands went asynchronous. Renames, signature changes and file renames used to freeze Emacs while refactor-nrepl analyzed the project - now they return immediately, show a spinner in the mode-line, and finish when the analysis does. Cold-cache runs on big projects are dramatically more pleasant.
• cljr-change-function-signature grew up: it can add and remove parameters now (not just reorder and rename them), it understands multi-arity functions, and a long-standing parsing bug that broke it against recent CIDER releases is fixed.
• cljr-slash (the magic requires feature) learned a neat trick: entries in cljr-magic-require-namespaces can carry an :artifact coordinate, and when the namespace isn’t on your classpath, typing json/ will offer to add the library to your project and hotload it on the spot.
• A bunch of commands now work without a running REPL. cljr-slash and cljr-add-missing-libspec fall back to the static alias table, cljr-clean-ns falls back to sorting the ns form, and cljr-remove-let and the #(...) -> (fn ...) promotion are handled purely on the Emacs side. Refactoring your requires before the REPL is up is no longer a paper cut.
• Everything got snappier. Artifact lists and libspec suggestions are cached client-side (the latter matters because cljr-slash fires on every / keystroke), and the startup cache warming now actually populates the cache the interactive commands read from.
• clj-refactor now talks to refactor-nrepl using namespaced op names (refactor/clean-ns and friends), with a graceful fallback for older middleware versions. The companion refactor-nrepl 3.14.0 release also hardened the AST analysis and made find-usages noticeably faster on projects with many macros.
• The dependency diet continued: multiple-cursors, hydra and inflections are gone, along with a pile of aliases that had been deprecated since 2.3.0. clj-refactor is a much leaner package than it used to be.
• And a long tail of quality-of-life fixes - cljr-describe-refactoring now opens the wiki page in your browser instead of scraping HTML, the dependency commands give clear errors instead of raw search failures, and clojure-ts-mode users get a working offline ns sort and proper setup docs.

Upgrading

4.0 is a major release and it does come with breaking changes: the minimum requirements are now Emacs 28.1 and CIDER 2.0, the long-deprecated 2.3.0-era command aliases are gone (use the clojure-* equivalents that live in clojure-mode these days), and the legacy namespace-aliases code path in cljr-slash was removed along with its three configuration options. On the middleware side you don’t need to do anything if you use cider-jack-in - refactor-nrepl 3.14.0 gets injected automatically, and older versions keep working thanks to the op-name fallback. Most setups should upgrade without touching a thing, but do skim the changelog if you have a heavily customized configuration.

Five years later

Reading the 3.0 announcement again, I wrote back then that we wanted to show “we haven’t reached the limit of what one can do with a purely (mostly?) REPL-powered approach to refactoring”. I still believe that, and 4.0 is hopefully some evidence. The roadmap has the rest of the plan - including making the analysis fast and robust enough to erase the reasons people reach for other tools - and with CIDER 2.0 out the door I finally have some cycles to spend here.

Huge thanks to everyone who contributed to clj-refactor and refactor-nrepl over the years, to Clojurists Together for supporting the broader CIDER ecosystem, and to everyone who kept filing issues during the quiet years - they shaped most of what shipped in this release.

In the REPL we trust!

I feel like a bad Emacs user because, while I've been using it for a long time, it's only been in the past few months that I have embraced Orgmode as my task manager. Sometime I will probably write about my journey to this point, but for now I want to talk about a small annoyance I had in org-agenda.

I use org-agenda many times a day. I used to use the Week view (C-c a a) because it gives me an overview of what I finished and what is coming up. The problem is that a week is a fixed box. On Monday I saw a full week ahead of me. By Friday that list was mostly useless because all I saw were the tasks I'd finished earlier in the week and the few I had left, with next week's work still invisible – it won't show up until next week.

But that's not how I work. By Thursday I don't generally care what I finished on Monday, but I'd love a peek at what's coming. What I wanted wasn't a calendar week at all – I wanted a window that follows me, always showing a little behind and a little ahead, with today sitting near the middle.

In typical Emacs fashion, this was easy to do – it was three lines:

(setq org-agenda-span 6
      org-agenda-start-day "-2d"
      org-agenda-start-on-weekday nil)

The first two options make a lot of sense:

• org-agenda-span 6: show six days instead of a rigid calendar week.
• org-agenda-start-day "-2d": start two days before today. Org accepts relative date strings like -2d or +1w here, which makes this easy to tweak.

The third line is seemingly innocent but actually it's the one that matters the most. If you set only the first two, nothing changes. You'll tweak start-day, reload the agenda, and watch it snap right back to Monday, and you'll wonder if you fat-fingered a variable name.

You see, by default org-agenda-start-on-weekday is set to a weekday, and when it's set, Org rounds your start day back to that week boundary – silently overriding start-day. Setting it to nil tells Org to stop snapping to the week and honor the start day you actually asked for. Of course, its docstring explains it if you already know to go looking, but nothing points you there when your config silently fails.

Once I had that, I went looking for how to zoom in and out from my rolling agenda and found the view shortcuts:

• d - day view

• w - week view (so 7 full days)

• vt - fortnight (14 days)

• vm - month

• y - year

  To be more specific, v gives you a menu of options to choose from – everything that I listed here and more.

  None of this is strange – it's three variables that ship with Org. But org-agenda-start-on-weekday is a good reminder that in Emacs, the config item you want usually already exists, and so your reasoning should be less of "there's no setting for that" and more about "what setting am I missing?".

I have been working on two new themes for my minimalist doric-themes package. The original plan was to publish them together as part of the version 1.2.0 from a few days ago (the version that also brought doric-tiger and doric-lion), but then I decided to refine them further.

doric-lilac is a light theme, while doric-borage is dark. I am still testing them, though in the screenshots below you can get a first look.

Borage, by the way, occurs naturally in the mountains and there even is some in my land: all sorts of bees love it. I have seen lilac around, so I will need to transplant some of it here.

doric-lilac

doric-borage

Part of development

The new themes will be available in version 1.3.0. They already have the character I want from them, though I may still tweak some colour values.

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.

My Emacs file-finding habits go back a long way. I lived with vanilla find-file until I discovered ido-mode, and that was a big step up in UX. Later I moved most completion to helm — but C-x C-f stayed on ido the whole time: when helm-mode takes over the standard completion dialogs, helm-completing-read-handlers-alist lets you add per-command exceptions, and mine said (find-file . ido). Last December I finally rewrote my config around the modern stack — vertico, orderless, consult — and the vertico wiki even has a recipe for making it behave more like ido. Most of my muscle memory survived the move.

Except backspace.

Here is the difference. In ido-find-file, M-p/M-n move you between the directories you previously opened files in: you land in a directory, and from there each backspace takes you one level up. It is navigation, not text editing. Vertico’s M-p instead recalls the full path of a previously opened file, inserted into the minibuffer as ordinary editable text — which I actually like more: the file I want is often one I already opened. And when it is not, a recalled path is still my starting point. In a project I know well, project-find-file is only half of how I move around; just as often I navigate relative to a file I touched recently — a habit formed years before project.el or projectile existed: recall it, delete its name, go a level or two up or into a sibling directory. Which means pressing backspace — and this is where it breaks. Ordinary text gets ordinary editing: backspace deletes one character, except right after a slash, where vertico-directory-delete-char removes a whole path component. So I hold backspace to erase the long file name, it eats the name character by character — and the moment it crosses the slash, the still-held key starts deleting whole directories. Release a beat too late and half the path is gone.

The fix is a small replacement for vertico-directory-delete-char: when the point is at the end of the minibuffer and the input as a whole is an existing file path, treat backspace as “delete the last component” — exactly what my fingers expect after ido.

(defun my/-vertico-directory-delete-char (n)
 "Delete N directories or characters before point.
Like `vertico-directory-delete-char', but when point is at the end
of the minibuffer and the input is an existing file path, delete the
entire path component instead of a single character."
 (interactive "p")
 (cond
 ;; Active region: let `delete-backward-char' handle it.
 ((and (use-region-p) delete-active-region (= n 1))
 (with-no-warnings (delete-backward-char n)))
 ;; At a directory boundary, try to go up a directory. Also at end of
 ;; input, if the whole path is an existing local file, treat DEL as
 ;; directory-up (delete the last path component). Skip remote paths to
 ;; avoid blocking on network round-trips.
 ((and (or (eq (char-before) ?/)
 (and (eobp)
 (let ((mb (minibuffer-contents-no-properties)))
 (and (not (file-remote-p mb))
 (file-exists-p mb)))))
 (vertico-directory-up n)))
 ;; Otherwise, delete a character.
 (t
 (with-no-warnings (delete-backward-char n)))))

And the binding, replacing the stock one:

(keymap-set vertico-map "DEL" #'my/-vertico-directory-delete-char)

The file-exists-p check is the heart of it, not a safety net. It is what distinguishes a path you just recalled from history (it exists — backspace removes the whole name) from a name you are typing right now (it does not exist yet — backspace fixes the typo, character by character). Filtering input like init compl for orderless is likewise untouched. Two more details: remote paths are skipped on purpose, because file-exists-p on a TRAMP path is a network round-trip, and backspace is the last key that should ever block on the network; and mid-path behavior is stock — after a slash, backspace deletes a whole path component; inside a name, a single character.

One honest limitation: while erasing a typed name character by character, you can land on an existing prefix (deleting Makefile2 and reaching Makefile), and the next backspace jumps a whole component. In practice, I have yet to be bitten by it.

The result: recall a path from history, press backspace once — the file name is gone; every further press climbs one directory, deliberately. No more holding the key down, no more runaway deletion, and years of finger habits work again.

History recall is where the old behavior hurt the most, but the same rule pays off in ordinary navigation too: while the name you are typing matches no existing file, backspace edits it character by character; the moment the input is a complete file name — typed to the end or completed with TAB — a single backspace removes it whole. Funnily enough, ido is worse here: whenever there is text in the minibuffer, it deletes character by character. My ido habits, it turns out, were really about directory-oriented history — and where the two behaviors differ, I like the new one more.

Here is the commit in my config, with the use-package wiring around it.

Yesterday I wrote that I had reconsidered my stance on Jinx and decided to give it a serious try. The only problem I had was that picking the correct spelling wasn’t working as advertised. I speculated that this was probably the result of some interaction between Jinx and Ivy and this, indeed, turned out to be the case.

Embarrassingly, mbork had already pointed this out in his post about Jinx that I linked to but since I wasn’t planning on installing Jinx, I hadn’t paid it much attention. His solution was simple: he merely disabled Ivy for Jinx by advising jinx-correct. That works fine but I’m not sure that I like that behavior either. You have to press Tab to get the list corrections and then it isn’t any easier choose the right one.

I’m sure there’s something simple that I’m missing so I’ll continue experimenting or perhaps one of Irreal’s more knowledgeable readers will tell me I’m just being stupid. In any event, I’m going back to the original behavior until I can figure out the correct way of fixing things.

Two weeks ago I wrote that CIDER 2.0 was brewing. Today the brew is ready - CIDER 2.0 (“Terceira”)¹ is officially out! I promised the release would follow the preview within a week or two if nothing serious surfaced, and for once in my life I’m actually on schedule.

The preview post covered the big themes in detail - the transient menus, the call-graph browsers, cider-macrostep, the revamped tracing and enlighten, the ClojureScript improvements - so I won’t rehash all of that here. Instead I’ll focus on what changed between the preview and the release, and on the bigger picture of what CIDER 2.0 is actually about.

What CIDER 2.0 is about

Looking back at the (enormous) changelog, the release boils down to four themes:

• Tackle some ambitious ideas that had been lying dormant for ages - inline macro stepping, rich (content-type) results, source-aware cross-referencing. Some of the issues closed by this release were filed the better part of a decade ago.
• Polish the “understand your code” toolbox - the debugger, the macroexpansion facilities, tracing, enlighten, the stacktraces and the cross-references all got a serious amount of love.
• Make the whole CIDER experience more consistent and discoverable - transient menus everywhere, one tree-view widget shared by all the browsers, and a naming cleanup that brought a bunch of stragglers in line.
• Fix old annoyances - the friendly-session complexity that 1.22 started taming (remember the redisplay lag fix and default sessions?), the find-references gaps, the flaky SSH tunnels, the confused stdin handling.

Notice what’s not on that list - a pile of shiny new features. There are a few genuinely new things in 2.0, of course, but the heart of this release is that most of CIDER’s important features got overhauled (tastefully, I hope) or made more robust and faster. After 14 years you accumulate a lot of good ideas with rough edges; 2.0 is me going over them with fine-grit sandpaper.

What landed after the preview

Quite a lot, as it turns out - the last two weeks were busy. The headliners:

• Rich results are now on by default. Evaluate something that returns an image and it renders inline; a result that points to external content (a file, a URL) gets a [show content] button that fetches it only when you press it. HTML renders as formatted text, URLs are clickable. This works for regular C-x C-e-style evaluations too, not just in the REPL (configurable via cider-eval-rich-content-destination). Fun fact: content-type support was added way back in 0.17, disabled in 0.25 after it got a bit overzealous with the fetching, and the interactive-eval part was requested in 2018. Better late than never, right?
• The transient story got finished. The debugger and the inspector now have menus of their own (? and m respectively), and many menus grew argument flags - pick a pretty-printer per invocation, set test selectors once and reuse them across runs, toggle the refresh modes, pass aliases at jack-in. As before, your muscle memory is safe - the menus only help when you pause.
• There’s a new cider-doctor command that checks your Emacs setup and your active session for common problems (version mismatches, stale byte-code, leftover obsolete config) and produces a copy-pasteable report. My hope is that it will make “CIDER doesn’t work” bug reports a thing of the past - or at least give us something to look at when they arrive.
• Pending evaluations now show an animated spinner overlay right at the form you’re evaluating, instead of a spinner in the mode-line of a REPL buffer you probably can’t even see.
• The debugger got dusted off properly: quitting a debug session finally restores point to where you started - an issue filed in 2016 - the force-step-out key works again, and cider-nrepl 0.62 fixed a batch of instrumentation bugs (records surviving instrumentation, clear errors for forms too big to instrument, and a few crashes).
• Stdin handling got a long overdue overhaul - input prompts are routed to the session that actually asked for input, cancelling a prompt now interrupts the evaluation (instead of quietly letting it continue), and C-c C-d sends EOF for code that reads until end of input.
• Clicking a stack frame for a top-level anonymous function now jumps to the actual source instead of clojure.core/fn - a bug from 2020 - and ClojureScript frames render their ns/fn properly.
• A big consistency pass over the options: the REPL history browser is now cider-history, the inline-result options became a coherent cider-eval-result-* family, and the six per-buffer auto-select options collapsed into a single cider-auto-select-buffer. Every old name keeps working as an obsolete alias, so nothing breaks.
• And a long tail of robustness work - a slow memory leak on the eldoc/completion path, cider-classpath on Windows, formatting no longer corrupting multi-line strings, theme-aware colors for the nREPL message log, and plenty more of the same ilk.

The documentation also got restructured to be more approachable - there’s a proper quickstart now, a keybindings reference page, dedicated pages on using CIDER alongside clojure-lsp and clojure-ts-mode, and a guide for full-stack Clojure + ClojureScript projects. The manual has grown organically for over a decade, and it showed; hopefully finding things is much easier now.

Upgrading

Despite the big scary version number, upgrading should be uneventful. All the renames ship with obsolete aliases, the transient menus preserve the classic keybindings, and the only removals are commands that had been no-ops for years. The one bit of muscle memory you may need to adjust: cider-macroexpand-all moved from C-c M-m to C-c M-m a, as C-c M-m is now a prefix for all the macroexpansion commands. If anything feels off after the upgrade, M-x cider-doctor is your friend.

Fourteen years later

CIDER 0.1 (well, nrepl.el 0.1) was released on July 10th, 2012 - fourteen years (and five days) ago.² I’ve been reflecting on this a lot lately. Fourteen years is an eternity in our line of work - entire ecosystems have come and gone in that time - and yet here we are, still innovating, still improving, still moving forward. I dare say CIDER 2.0 is the strongest release in the project’s history, and it’s certainly the one I’ve enjoyed working on the most.³

None of this would have been possible without the people and organizations who have supported the project over the years - everyone who contributed code, reported issues, wrote about CIDER, answered questions, or backed the project financially. A special thanks to Clojurists Together for their long-standing support, and to everyone who took the snapshot for a spin after the preview post and shared feedback - several rough edges got filed down because of you.

So, go play with CIDER 2.0! Kick the tires, explore the menus, crack open some values in the inspector, step through a macro or two. And if CIDER makes your work a little nicer every day, consider supporting its future development

• that’s what keeps CIDER and friends going.

Where to from here? The sky is the limit. The REPL is the inspiration. The best is always yet to come…

Keep hacking!

mojopad

Product: MojoPad — a thinking space for your Mac · second brain & PKM
Price: $59

Some of you might remember VoodooPad. It was a product marketed with the tag line “VoodooPad - You put your brain in it”

I used it a long time ago. After version 5, the product got sold to a new developer who promised version 6. Users of VoodooPad have been waiting for a long time for that. We are still waiting.

Paul Korn in the Miss the old VooDooPad? · Outliner Software post described MojoPad as “VooDooPad definitely was wonderful – and it’s wonderful to see a sort of tribute-band modern version.”

I don’t remember everything VoodooPad used to do or how it did it. In this article I am going to cover what MojoPad does and not worry about comparing it to VoodooPad.

I would describe MojoPad as VoodooPad remixed for the modern age. Yes, the product is inspired by VoodooPad, but it does so much more that the comparison is not fair to it.

TL;DR: If you are looking for a PKM application which is innovative, comprehensive, and one you can live in, check out MojoPad.

Caveats: MojoPad is an Electron application. If you have a visceral negative reaction to all Electron applications, you are better off avoiding reading further. If you can see past that, you might want to read on and try out a product which could become the centerpiece of your writing life.

First Things First

MojoPad comes with a great manual. Go read it first. MojoPad is a deep product and you are going to read the manual a few times. Go through it once. You are not going to remember all of it. It is large. But you are going to have an idea of what the toolset of MojoPad is. That will guide what you use it for. You can find the manual in the Help menu. It is a MojoPad document.

MojoPad is Pretty

pretty

The first thing that strikes you when you launch MojoPad is that it is pretty. One could never accuse VoodooPad of that. It comes with a collection of themes and is nice to look at.

OK, but What Is It?

Marketed as “A Digital Playground For The Mind” MojoPad is a personal wiki. We have all become used to wikis in the context of “knowledge-management” programs like Obsidian. MojoPad is that. You surround a selection of words with two square brackets, that becomes a link. You click on it and the program takes you to a new page. You can link both to a new page or to an existing page. Conceptually it is a website on your local machine containing links to and from parts of the document you are working on. It is a powerful metaphor for managing your notes, projects, and writing.

Settings

themes

MojoPad has a nice collection of themes.

more customization

Some more choices to make the program look pretty and customize it to your taste.

links

You get to open the links in the same window you are on or in a new tab. I love the preview bubble. Probably not useful, but it is an interesting look. You hover over a link and a bubble showing the first few lines pop up. Pretty.

editing

You get to choose the default font for the editor, the font for the headings. Interestingly, you can specify a font for the Markdown source view. Love Lexend — Change the way the world reads. and am using it almost everywhere I can. Zed Mono, a forked Iosevka, is the default Markdown font for me. You have some of the usual typographic controls.

shortcuts

This is the feature which makes me love MojoPad. Every keyboard command is customizable. You can change it all. Use the ones you are used to. If you are used to outliners or text editors, you have favorites merged into your muscle memory. Use them in MojoPad. Makes using it easy.

web clipper

MojoPad has a good web clipper. It is an extension for Chrome and a bookmarklet for Safari.

backup

There is a backup function and you can specify the location of the backup. Gives me peace of mind.

location, date, and time

You get to specify the date and time formats and your location in the application.

Choice of Formats

MojoPad lets you choose your document format. You can work in rich text, plain text, or Markdown. Of course, I choose to work in Markdown.

It has a full-featured outliner mode (more on that later).

Edit Page in External Editor

external editor

You get to assign an external editor to the program. If you prefer writing in another program, you can assign an editor as your external editor and use that to write. MojoPad is not bad as an editor, but I prefer Emacs or iA Writer, so I use this function a lot.

A keyboard command switches the present page to the external editor. I work on it there, save it and come back to MojoPad.

Writing in MojoPad

Writing in MojoPad is a good experience. You get to choose your own fonts and it has typewriter scrolling with nice themes. You have great typographic control and can control spaces and distance between lines and paragraphs.

For me, the usefulness of an editor is a function of its support for keyboard commands. I don’t like mousing around and MojoPad’s support for keyboard commands and the ability to customize them to my liking makes it a great environment to write in.

A few words about formats. MojoPad supports rich text, plain text and Markdown. I don’t care about rich text, so I have no input on that. The Markdown support is excellent. It doesn’t deal with Org-mode in the sense that it doesn’t do any syntax highlighting of Org-mode files, but it treats them as plain text files and that is enough for my use.

MojoPad has an outlining mode. A document can be treated as an outline document and it supports all of the features that make a good outliner. I have been using it for a while and haven’t found anything that I am missing. It is well implemented. The interesting thing about MojoPad is lot of the features of an outline are shared by Markdown mode. Same keyboard commands, same general structure and the same ease of dealing with documents. At this stage, MojoPad is a great outliner along with its other features.

There are small touches in MojoPad which make writing in it simple and efficient. Some of the ones I am fond of:

You can fold/unfold headings and reduce distractions while you are writing.

The command Open Folder as Longform… makes it possible to view multiple pages as a stream. You can choose the pages or it can follow the folder structure, gives you a sense of how the document will flow if presented in a particular sequence. Useful.

Another command which I use all the time is Open Side by Side… This lets me get two views into the same document or a view into a different document while working. I use this feature a lot.

Tasks and Projects

MojoPad has a an implementation of tasks and associated projects. I have not explored this much. My tasks and projects are maintained in Emacs through Org-mode. But I have rudimentary task lists in MojoPad and they work great giving me the opportunity to break up a big task into its component pieces and providing a running tally of how many of the sub-tasks have been completed out of the total number of sub-tasks. Another useful touch.

Additional Features

There is a Kanban board, and a Canvas implementation in MojoPad. I have not explored those. Nor have I explored the Mermaid diagrams implementation. I suggest that you read the manual of MojoPad. That is where all of the features are detailed and it is an invaluable resource if you are going to be using this program. You will discover many goodies hidden there. The documentation is excellent and it is free. Use it.

The Developer

Mark Busse is the developer of MojoPad. I have never interacted with a developer like Mark. He is on the ball. I find a bug, or a feature request, and send it to him. It almost seems like the fixes/additions make it to the program before the send is complete. He is on it. I suspect he is a super-spy who keeps a close watch on my brain waves to monitor what he can find out about my usage of MojoPad. Seriously, he is responsive and absolutely phenomenal when it comes to fixing bugs and adding features. It is an unqualified pleasure dealing with a developer who is that responsive.

I am impressed and I would use MojoPad only because of his attitude and talent. The product now has a blog at Blog — MojoPad and a community discourse channel at MojoPad. Join up, ask questions, opine, and contribute to the future direction of MojoPad.

Improvements

I cannot think of anything I would suggest and that is extremely rare for me. OK, maybe one thing. I know it is an Electron app and it chews up memory. I would like an attempt to control the amount of memory the application eats up. The speed of the application is not a problem, the memory usage is. A focus on reducing that would be a welcome addition.

Conclusion

You can live in MojoPad. This can be the central node of your writing life.

I recommend MojoPad heartily.

Thanks: Thanks to the developer who provided me with a review license for the product when I asked for one.

Still working with Claude on my Emacs settings as a reference. Need to start a new session, so asked it to write a summary with instructions on how I like it to help me. It wrote this:

I know it’s complementing me on purpose, but that emphasized why? That’s why my blog is called this way 😉

C'est merveilleux ! Prot a répondu à ma vidéo et il adhère à mon idée folle d'essayer des conversations sur Emacs avec d'autres personnes en français, malgré mon niveau débutant. Prot est aussi en train de pratiquer son expression orale, donc c'est parfait. Comme Prot l'a dit, je dois parler sans peur. Tout le monde est patient, et si on n'est pas patient, on peut partir. ;)

Voulez-vous parler d'Emacs avec Prot et moi ? Je pense que ce sera comme mes conversations Emacs Chat en anglais. L'objectif est principalement le partage de chouettes idées sur votre flux de travail et votre configuration, au lieu de se focaliser sur moi. Je devrais donc pouvoir survivre avec mon français. Peut-être que le chat web me sauvera si je suis bloquée. Je peux probablement aller loin avec quelques expressions comme:

• Qu'est-ce que vous faites avec Emacs ?
• Comment êtes-vous tombé amoureux d'Emacs ?
• En lisant votre configuration, j'ai remarqué que…
• Oh, dites-nous en plus sur la façon dont vous l'utilisez.
• Y a-t-il un raccourci clavier ou une petite astuce préférée ?
• Comment avez-vous fait ça ?
• C'est incroyable, je n'avais aucune idée qu'Emacs pouvait faire ça !
• Quel conseil donneriez-vous à quelqu'un qui commence tout juste à apprendre ?

Je pense que ma fille se lève plus tard pendant l'été. Si je planifie des sessions tôt (pour moi), nous pourrons probablement avoir une conversation avant que je doive m'occuper de mes activités de maman. Par conséquent, j'espère être disponible (America/Toronto; UTC-4 à ce moment; si vous avez Javascript et si vous lisez ceci sur mon site, vous pouvez cliquer sur l'heure pour convertir à votre fuseau horaire):

• [2026-08-06 Thu 07:30]–[2026-08-06 Thu 08:30] Richard Bonichon: Github
• [2026-08-13 Thu 07:30]–[2026-08-13 Thu 08:30]
• [2026-08-20 Thu 07:30]–[2026-08-20 Thu 08:30] Abdallah Maouche (heiwiper): Gitlab, Github
• [2026-08-27 Thu 07:30]–[2026-08-27 Thu 08:30]

Si vous souhaitez me rejoindre pour une des séances, s'il vous plaît, envoyez un courriel à sacha@sachachua.com avec vos dates préférées, puis je vais m'organiser avec Prot. Si aucun de ces créneaux horaires ne vous convient, veuillez nous en suggérer d'autres et nous verrons si c'est possible.

Si vous incluez des liens vers votre configuration ou votre site, je pourrai préparer des notes et chercher des mots dans le dictionnaire. =)

( Et si mes tentatives inspirent d'autres personnes à partager leurs apprentissages malgré leur envie de toujours peaufiner, ce sera incroyable. )

D'autres sujets dans ma vidéo pour Prot :

Faire du shadowing consiste à écouter un exemple court et à le répéter immédiatement (peut-être plus lentement ou à la même vitesse) pour imiter la prononciation et le rythme. Si je suis sur mon ordinateur, c'est facile d'utiliser les sous-titres pour répéter une phrase, mais jusqu'à présent, je n'ai pas de flux de travail similaire sur mon téléphone sauf pour faire du shadowing sur des phrases avec la synthèse vocale dans Chrome. Je suis sûre qu'il y a beaucoup d'applications qui demandent un abonnement pour offrir cette fonctionnalité, mais comme vous le savez, je veux exploiter Emacs (ou mes propres logiciels) au maximum. Un jour, peut-être !

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

In a stunning case of the Baader–Meinhof phenomenon, I’ve been running across the Jinx spelling corrector everywhere. I had never heard of it until last week when I watched and wrote about Prot’s video on writing in foreign languages with Emacs. Then Marcin Borkowski wrote about it and I posted about that. In all those instances, I concluded that Jinx was interesting but mainly of use for those who regularly wrote in more than one language. Since I seldom do that, I decided I was going to stick with flyspell.

Then Omar commented on my Borkowski post saying that Jinx was a better solution than flyspell even if you used it with only one language. I thought that perhaps I should reconsider my decision about sticking with flyspell. Finally, I saw this post by Bozhidar Batsov on why he has recently switched from flyspell to Jinx and became convinced that I should give it a try.

I installed it without difficulty and am writing this post with it as a sort of maiden voyage. So far, everything seems fine. By default, jinx-correct is bound to Meta+$, which I find a little clumsy so I changed that to Ctrl+;, which is where my muscle memory thinks it should be.

The only problem I’ve had is quickly choosing the correction. The documentation says that you can do that put typing the number of the correction but that simply exits the correction leaving the old spelling in place. The problem may be some interaction with Ivy, which I’ll investigate as soon as I get some time.

Yesterday I published a post about Jinx, where I mentioned in passing that dropping Flyspell freed up C-. and C-; for embark, and that this would be a topic for another article. Well, here it is!

Embark has been around for quite a few years, and pretty much everyone in the vertico/consult crowd swears by it. Somehow I never got around to adopting it until my recent config overhaul, and now I keep asking myself why I waited so long.

So, What’s Embark?

Embark, written by Omar Antolín Camarena, is often described as a keyboard-driven right-click menu for Emacs, and I think that’s a pretty apt description. You point it at something - a minibuffer candidate, a file name, a URL, a symbol - press C-. (embark-act) and you get a menu of actions that make sense for that particular thing. A few examples:

• On a buffer in C-x b? You can kill it, rename it, or diff it against its file without leaving the minibuffer.
• On a file in C-x C-f? You can delete it, rename it, copy its path, or open it in another window.
• On a URL in a buffer? You can browse it or copy it.
• On an Elisp symbol? You can jump to its definition or look up its documentation.

The beauty of it is that you don’t have to abort the minibuffer session, fiddle with dired or remember some obscure command name - the action comes to you, right where you are.

Here’s the action menu you get when you press C-. with point on a URL:

There’s also embark-dwim (C-; here), which skips the menu and runs the default action directly - it opens the URL at point, visits the file at point and so on. I find myself using it all the time for the common cases and reaching for the full embark-act menu when I need something more exotic.

The Killer Feature: embark-export

Acting on a single thing is nice, but embark-export is where Embark really shines. It takes the entire set of minibuffer candidates and dumps it into a buffer of the appropriate major mode:

• consult-ripgrep/consult-grep results become a grep-mode buffer
• consult-line results become an occur buffer
• file candidates become a dired buffer
• buffer candidates become an ibuffer buffer

You trigger the export from within the action menu - e.g. C-. E while in the middle of a consult-ripgrep session.

In other words - you start a quick search in the minibuffer, and if it turns out to be something bigger, you promote it to a proper buffer you can navigate, save for later, or (my favorite) edit in place with wgrep (C-c C-p in the exported grep buffer) and apply the changes across all the matched files. Once this workflow clicks, there’s no going back.

Tips and Tricks

A few more things I picked up in my first days with Embark that you’ll probably want to know about:

• Press C-h right after C-. to get a searchable completing-read menu of every applicable action, and run the one you pick. This is both the best way to discover what Embark can do and a lifesaver when you’ve forgotten a key.
• C-. i inserts the current candidate in the buffer you came from and C-. w copies it to the kill-ring. Sounds mundane, but grabbing a file path or a variable name from the minibuffer this way quickly becomes second nature.
• C-. A (embark-act-all) acts on all the candidates at once - think killing every buffer matching your current input in one go.
• C-. B (embark-become) replaces the current minibuffer command while keeping the input you’ve typed. Started C-x C-f, but realized you actually need consult-buffer? No need to abort and start over - just “become” the other command.
• By default acting on a candidate exits the minibuffer. Call embark-act with a prefix argument (C-u C-.) to keep the session alive - handy when you want to, say, delete a few files in a row. (see embark-quit-after-action if you prefer to flip the default)

Embark Meets Projectile

Being the Projectile maintainer, I obviously had to check how well Embark plays with it. The answer is - pretty well, actually! Projectile advertises the completion category of its candidates, and Embark knows how to resolve a project-relative path like lisp/init-git.el to a full path before acting on it.¹ This means the whole file action arsenal works in projectile-find-file:

• C-. w - copy the full path of a project file without visiting it
• C-. r - rename a file (no dired detour needed)
• C-. d - delete a file you just realized shouldn’t exist
• C-. j - jump to the file’s location in dired

projectile-switch-project is even more fun, as there the candidates are the project directories themselves:

• C-. j - browse a project in dired without actually switching to it
• C-. $ - open eshell directly in some project’s root (Embark is smart enough to run shell actions in the target’s directory)
• C-. w - copy a project’s path
• C-. E - export the entire list of your known projects to a dired buffer

That last one makes for a pretty nice project dashboard, if you ask me.

You can also teach embark-become about Projectile. Out of the box its file/buffer map offers p for the built-in project-find-file, but we can easily add a Projectile equivalent:

(with-eval-after-load 'embark
  (keymap-set embark-become-file+buffer-map "P" #'projectile-find-file))

Now when you start a plain C-x C-f and realize the file is somewhere deep in the current project, C-. B P will re-run your input through projectile-find-file instead. No retyping needed.

Note: One small asymmetry - C-. E in projectile-find-file currently produces an Embark collect buffer rather than a dired buffer, as the exporters operate on the raw completion category. Still useful (you can keep acting on the candidates from there), just don’t expect wdired magic.

Note: The exporters for the various consult commands live in the embark-consult package, so you’ll want that one too if you’re a consult user.

The Setup

Here’s the relevant bit of my config:

(use-package embark
  :ensure t
  :bind (("C-." . embark-act)
         ("C-;" . embark-dwim)
         ("C-h B" . embark-bindings))
  :init
  (setq prefix-help-command #'embark-prefix-help-command))

(use-package embark-consult
  :ensure t
  :hook (embark-collect-mode . consult-preview-at-point-mode))

C-. and C-; are the bindings suggested by Embark’s README and they are quite comfortable, provided nothing else is squatting on them.² The prefix-help-command bit is a small gem on its own - press C-h after any prefix (say C-x) and instead of the regular help buffer you get a completing-read over all the bindings in it, which you can narrow and execute directly.

Embark doesn’t really care which minibuffer completion UI you’re using - it works fine with vertico, icomplete and even the default completion setup.

Closing Thoughts

Embark is one of those packages that are a bit hard to explain, but make total sense the moment you try them - the “aha” moment for me came the first time I exported a consult-ripgrep session. It has certainly earned its place in the small set of packages I’d install on day one.

Are you using Embark already? What are your favorite actions? I’d love to hear about them in the comments!

That’s all I have for you today. Keep acting (on all the things)!

Just a few days ago, Human Emacs was published: a declaration signed by more than 50 people from the community, led by technomancy, announcing that if GNU ends up accepting LLM-generated contributions in Emacs, they are prepared to maintain a fork free of AI-generated code. They have also opened a mailing list to discuss the topic and a chat channel on Libera Chat. Naturally, debates have appeared elsewhere too, such as Hacker News, Lobsters and Reddit. The debate is on.

I notice a lot of tension in the community. Every time I leave a comment in a thread supporting some point contrary to Human Emacs, I receive downvotes and flags for off-topic, spam, troll and unkind. That is why I thought it appropriate to develop my opinion on my blog, where there is room for nuance without the pressure of votes and labels.

That said, it is worth separating two debates that are being mixed together. The first one belongs to GNU and the FSF, the legal matter: if LLM-generated code cannot be copyrighted, it could weaken copyleft.

The licensing arguments seem legitimate to me, but easy to get around. Today you can work with a free LLM, with open weights, running on your own machine. If the purity of the tool really mattered, we should not accept patches typed on Windows with a proprietary IDE. If code is the heart of free software, we should only care about it being useful, maintainable and of good quality, regardless of its origin. And if what matters is the person behind it, we are entering territory that has already been settled: contributions developed by private companies are accepted.

The second one belongs to the Human Emacs signatories, and it is purely ethical. They make it clear themselves in their "Not Under Discussion" section:

We are not here to discuss whether LLMs are effective at what they are claimed to be able to do; their effectiveness is not at all relevant to the question of whether their use can be part of a principled software movement dedicated to user empowerment.

This stance has the virtue of being honest: they are not discussing whether LLMs work, they are discussing whether they fit their principles. And there is no possible debate against someone's principles. I will only say that I do not share the premise that LLMs are incompatible with user empowerment: for someone who cannot program, being able to add a complex feature to their editor is precisely empowerment.

I fully understand the right to fork, and I defend it: I maintain emacs-gpu myself. Forking is the essence of free software, and having an Emacs without AI code for those who want it seems healthy to me. What I find harder is the practical side: there is no reliable way to detect LLM-generated code, so the policy can only rest on trust and each contributor's voluntary disclosure. And we already know where that leads: a few weeks ago a 92-line performance patch was rejected on emacs-devel precisely because its author disclosed that it had been drafted by an open-weights model, even though they reviewed it, modified it, tested it and took legal responsibility for it themselves. If they had kept quiet, nobody would have known. A policy that punishes honesty only produces less honest contributors.

Personally, I believe LLMs will improve Emacs in areas where it was not possible before. It is already happening with very complex bugs and with abstraction layers that required an enormous amount of human work that nobody was willing to do. And although I understand that LLM-written code in the core is not the same as human-written packages that use LLMs, such as gptel or agent-shell.el, I struggle to see the coherence between rejecting the former outright and celebrating that the latter is bringing fresh air into the ecosystem. I believe that, deep down, there is more human fear than real problem: perhaps the root lies neither in the LLMs nor in the FSF, but in the uncertainty that such a big change stirs in us. And that fear runs both ways: fear that LLMs will degrade what we love, and fear of falling behind by not using them. The Emacs community has always been very open to new ideas, and I would like it to stay that way.

Say you go jump to a header in org-mode somewhere with C-c C-o. Did you know that you can go back with C-c &? And that it has history, so you can keep going back??

Years of isearch-backwards… wasted. Mind blown. 🤯

There's some more buzz about spell-checking with Jinx (Bozhidar Batsov, Marcin Borkowski). Also, quite a few people have signed up for the Human Emacs initiative.

• Upcoming events (iCal file, Org):
  • London Emacs (in person): Emacs London meetup https://www.meetup.com/london-emacs-hacking/events/315050696/ Tue Jul 14 1800 Europe/London
  • Emacs Berlin: In-Person-Only Emacs-Berlin Stammtisch https://emacs-berlin.org/ Tue Jul 14 1900 Europe/Berlin
  • M-x Research: TBA https://m-x-research.github.io/ Wed Jul 15 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/UTC - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • OrgDevMeetup https://bbb.emacsverse.org/rooms/orgdevmeetup Sat Jul 18 0100 America/Vancouver - 0300 America/Chicago - 0400 America/Toronto - 0800 Etc/UTC - 1000 Europe/Berlin - 1330 Asia/Kolkata - 1600 Asia/Singapore
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Jul 25 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/UTC - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
• Beginner:
  • Learning Vanilla Emacs from Scratch with Prot as a Neovim User (Reddit)
    • Summary of the keymaps and lessons learned in the first coaching session | linkarzu
• Emacs configuration:
  • Bring back the Insert key on Emacs (Irreal)
  • Protesilaos: Emacs: global keybinding overrides (YouTube 12:46, Irreal)
  • Hel — Helix emulation layer for Emacs (Reddit)
  • Kristoffer Balintona: emacs-guix-starter: I’m glad this exists
  • Elegant Emacs (Reddit)
  • My emacs config. (Reddit)
• Emacs Lisp:
  • TIL `remove-hook` is interactive!
  • In Emacs, Everything Looks Like a Service (Reddit, HN)
  • Emacs Redux: Reading syntax-ppss State Without the Magic Numbers
• Appearance:
  • Protesilaos: Emacs: doric-themes version 1.2.0
• Navigation:
  • How to search among all files in, or below, a directory find-name-dired, consult-find-fd, fzfa
  • Srijan Choudhary: 2026-07-12-001 tip about global mark ring, C-x C-SPC, consult-global-mark
  • wisp: Whitespace to Lisp now supports sexp-movement
• Writing:
  • Marcin Borkowski: Fast spell-checking in Emacs with Jinx
  • Emacs Redux: Replacing Flyspell with Jinx (Irreal)
  • HyWiki: Zero Markup Hypertext (YouTube 23:24, r/emacs, r/orgmode)
• Org Mode:
  • Help wanted:
    • Feedback requested: minor mode for precise editing of hidden text
    • Org Mode requests: [FR] Re: [DISCUSSION] Restructuring LaTeX output: the bigger picture => a) ox-beamer.
    • Org Mode requests: [RFC] Help with PDF/UA2 accessibility tests for ox-latex
  • [02] Vanilla Emacs with Prot: I’ll Repent for My Markdown Sins - YouTube (Protesilaos) Beginner coaching session
  • Sacha Chua: Chatted with John Wiegley and Karthik Chikmagalur about personal information management (@oantolin@mathstodon.xyz) dealing with 40,000 entries, of which 818 are open TODOs
  • Raymond Zeitler: Numeric Priorities in Org Mode
    • Raymond Zeitler: One Hundred Times the Highest Priority (Irreal)
  • TAONAW - Emacs and Org Mode: A Quick org-mode Internal Links Reference
  • Import, export, and integration:
    • Chris Maiorana: Org mode as a gantt chart generator
    • Raymond Zeitler: Comment on Org Source Blocks (Irreal)
    • Randy Ridenour: Beamer-Style Typst Slides Using Org Mode (@randyridenour@zirk.us)
    • Vulpea sync is finally, actually async (opt-in)
• Completion:
  • emacs fido frame (Reddit)
• Coding:
  • A Emacs library to display magit changes in treemacs view (Reddit)
  • James Dyer: VC Shuttle: Advice-Based Git Sync for Air-Gapped Emacs
• Math:
  • Underappreciated Emacs built-ins: Emacs calc embedded
• Shells:
  • Ghostel 0.43.0 released: native Windows support (Reddit, @dakra@fosstodon.org)
• Mail, news, and chat:
  • Aimé Bertrand: Preserving email dates when moving messages in Mu4e
• LLMs:
  • agent-shell-dashboard (Reddit)
  • OrgA, An LLM agent's logic, knowledge, and chat all in one file (Reddit)
• Community:
  • Human Emacs (@technomancy@hey.hagelb.org, lobste.rs)
  • Emacs ATX meetup. July 2026. pi; gptel; completion-preview; prisma; remoto. (02:06:40)
  • History of Emacs the Text Editor/Operative System (14:47)
  • Andros Fenollosa: An alternative to Webmentions for the Emacs Carnival (@andros@activity.andros.dev) org-social
• Other:
  • A Tree and a Server Walk Into a Core… (July Emacs Carnival)
  • Jetpacs: A Jetpack Compose GUI wrapper for Emacs — Quick Showcase (Reddit)
  • EmacsURL.app lets Emacs open local or remote files via URL on the Mac
• Emacs development:
  • Make woman-topic-history an obsolete alias
• New packages:
  • folio-theme: Warm paper-like theme built on Modus and Ef (MELPA)
  • mise-tasks: Run mise tasks and highlight lockfiles (MELPA)
  • ox-mom: Groff MOM Macro Back-End for Org Export Engine (MELPA)
  • synaxis: Feed reader with SQLite storage (MELPA)

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

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

As I mentioned yesterday, I started organizing (and cleaning) my Emacs config. What may have seemed like an annoying and boring task has proven to be fun and addicting (reminds me of this, which is part of this video 😂).

I’ve already discovered a couple of new improvements to my current config as I was researching individual settings and why I have them, and as I said I do plan to share it. For now though, one important section I added to my config is a quick org-mode links reference. This is actually the first time I figured out the difference between radio links and “regular” plain links and how to use them.

Here it is, slightly modified:

Org-ID

We know about links to other files using org-id: You give a header an :ID: property (this is generated automatically¹ when you link to a header) and you get a slug, usually a UUID (for me it’s something slightly else, more on that soon below). This stores the links in org-id-locations, which in turn points to a local file with all of these unique IDs. This is good for linking between headers in different files.

Custom-ID

We can set a :CUSTOM_ID: property for a header, and it’s only active in that file. Kind of like a table of contents in a book, with chapters (= headers) listed. If you don’t have the book, you don’t have its table of contents, so you know nothing about it. To point to a header that has a custom ID: [[#custom-id-value][description]].

Plain Target and Radio Target link

These are buffer-specific only (no cross-reference between files). In this case, the links are tied to words (anchors), not headers. There are two kinds.

The regular plain target link works when we set the anchor first with <<an anchor>>, then call it again with [[an anchor]].

Its more “magical” brother is a radio target link, where we set an anchor like so <<<very special anchor>>> (three angle brackets) and then all we need to do is type very special anchor (no brackets this time), and it works. Note though that when you create a radio target for the first time, you have to revert the buffer or M-x org-update-radio-target-regexp for it to take effect.

Footnotes

¹ : this can be done with a function, org-id-get-create. For a deeper dive into how and why I set my org-id with a date format (not UUID), look here.

I’ve been using corfu for in-buffer completion for a while now and I’m quite happy with it. There was one thing that kept bugging me, though - the completion popup would only ever show whatever the current major mode’s completion function had to offer. No plain word completion, no file name completion - if the major mode (or your LSP server) didn’t know about something, neither did the popup.

Turns out I was simply missing one piece of the puzzle, namely cape.

The Problem

A bit of background first. Modern Emacs completion is built around completion-at-point-functions (capfs for short) - each major mode registers a function that knows how to complete things in its buffers, and UIs like corfu (or the built-in completion-at-point) simply display the results.

The catch is that most major modes register only their own capf. That’s why the trusty old dabbrev-style completion (complete any word that appears in your buffers) is nowhere to be found in the popup, even though most of us have been relying on it for decades via M-/.

Enter Cape

Cape (Completion At Point Extensions) is another package by the prolific Daniel Mendler and it does exactly what its name suggests - it provides a bunch of extra capfs that you can mix into any buffer:

• cape-dabbrev - complete words from the current and other buffers (the star of the show, in my opinion)
• cape-file - complete file paths
• cape-keyword - complete programming language keywords
• cape-elisp-symbol - complete Elisp symbols anywhere (e.g. in comments or docstrings)
• cape-dict - complete words from a dictionary file
• cape-line - complete entire lines from the buffer
• cape-emoji - complete emoji, if that’s your thing (Emacs 29+)

My setup is deliberately minimal - buffer words and file names everywhere, on top of whatever the major mode provides:

(use-package cape
  :ensure t
  :init
  (add-hook 'completion-at-point-functions #'cape-dabbrev)
  (add-hook 'completion-at-point-functions #'cape-file))

That’s it. Now when I type a few characters, corfu shows the major mode’s candidates and falls back to buffer words when there’s nothing smarter to offer. Typing a path like ~/proj offers to complete it as a file name. It’s one of those small quality of life improvements you stop noticing after a day, because it feels like it has always been there.

Note: Every cape capf is also an interactive command, so you can invoke them on demand - e.g. M-x cape-file to complete a file name regardless of your setup. Cape’s README suggests putting them on the C-c p prefix, but for me (and my fellow Projectile users) that’s a no-go, as C-c p is Projectile territory. Pick your own prefix if you want quick access to them.

Tips and Tricks

A few practical things worth knowing:

• Type file: anywhere and cape-file kicks in for the text right after it, even in places where a path wouldn’t normally be recognized (say, in the middle of a comment). The prefix is customizable via cape-file-prefix.
• cape-dabbrev gathers its candidates from buffers with the same major mode by default, so your Elisp buffers won’t pollute the completions of your Clojure buffers. If you want different behavior, that’s cape-dabbrev-buffer-function.
• If you set tab-always-indent to complete (as I do), TAB becomes the perfect trigger for the whole completion stack - it indents the line if needed and otherwise summons corfu with all your capfs, cape ones included:

;; smart tab behavior - indent or complete
(setq tab-always-indent 'complete)

• cape-dict reads from /usr/share/dict/words by default, which is fine on macOS and most Linux distros, but you can point cape-dict-file to any word list - e.g. one for your native language.

A Couple of Power Tricks

Cape also ships a few combinators that are worth knowing about:

• cape-capf-super merges several capfs into one, so their candidates show up in a single unified popup. (e.g. you can blend eglot’s completion with cape-dabbrev)
• cape-company-to-capf converts company-mode backends into capfs, which is super handy if there’s a company backend for your favorite tool but no capf in sight.

I haven’t needed either of them yet, but it’s good to know they are there.

Closing Thoughts

If you’re already on the vertico/consult/corfu bandwagon, cape is pretty much a mandatory addition - corfu deliberately stays small and focused, and cape is the intended way to extend what it can complete.¹ Funny enough, I went years without it simply because I never stopped to ask why file names wouldn’t complete in the popup. Sometimes you don’t know something is missing until you try it.

What’s in your completion-at-point-functions? Any cape goodies I’ve overlooked? Let me know in the comments!

That’s all I have for you today. Keep completing (at point)!

I’ve been using flyspell-mode for the better part of two decades, and I’ve written about it a couple of times before. It gets the job done, but it has always felt a bit creaky to me - it checks words one at a time as you type, flyspell-buffer is painfully slow in big buffers, and you have to remember to enable flyspell-prog-mode in your programming modes, so it would check only comments and strings there.

Recently, as part of the ongoing overhaul of my personal Emacs config, I finally replaced it with jinx and I can already tell you that I’m not going back.

Why Jinx?

Jinx is a modern spell-checker by Daniel Mendler (of vertico, consult and corfu fame), built on top of libenchant.¹ Quite a few things make it a great alternative to Flyspell:

• It’s fast. Jinx checks only the visible part of the buffer (it hooks into Emacs’s JIT font-locking machinery), so it doesn’t matter if your buffer is 100 lines or 100,000 lines long. There’s no need for anything like flyspell-buffer - misspellings simply get highlighted as they scroll into view.
• One mode everywhere. global-jinx-mode replaces both flyspell-mode and flyspell-prog-mode. Jinx decides what to check based on faces, so in programming modes it automatically limits itself to comments and strings.
• Enchant is a facade over many spell-checking backends - Hunspell, Nuspell, Aspell, and (notably) AppleSpell on macOS. That last one means Jinx can use macOS’s built-in dictionaries and you don’t have to install any yourself.
• Support for multiple languages at once. Set jinx-languages to something like "en_US bg" and Jinx will check both English and Bulgarian in the same buffer. As someone who writes in two languages every day, this alone would have sold me on it.
• A much nicer correction UI. M-$ (jinx-correct) pops up a completing-read menu (lovely if you’re using vertico) with the suggestions, plus entries for saving the word. More on that in a bit.

Here’s Jinx flagging a few typos for me:

The Setup

Here’s the relevant bit of my config:

(use-package jinx
  :ensure t
  :hook (emacs-startup . global-jinx-mode)
  :bind (("M-$" . jinx-correct)
         ("C-M-$" . jinx-languages)))

M-$ is bound to ispell-word by default, so rebinding it to jinx-correct feels quite natural. jinx-languages allows you to switch the active languages for the current buffer on the fly.

Note that those bindings are not optional - Jinx doesn’t bind any keys globally and jinx-mode-map is empty, so out of the box there’s no way to even trigger a correction! The package does come with a few handy bindings of its own, but they live on the misspelled words themselves (via overlay keymaps) and are active only while point is on one of them. More on that in the next section.

One thing to keep in mind - Jinx uses a small native module to talk to libenchant, and this module gets compiled automatically the first time you enable the mode. In other words - you’ll need libenchant (plus pkgconf) and a C compiler on your system:

# macOS
brew install enchant

# Debian/Ubuntu
sudo apt install libenchant-2-dev pkgconf

Admittedly, that’s a bit more setup than Flyspell, which is built-in and only needs an external aspell/hunspell binary. Flyspell will probably remain the path of least resistance, but in my opinion the small extra effort pays for itself many times over.

Essential Keybindings

In the spirit of Essential Flyspell, let’s go over the keybindings you actually need. The nice thing about Jinx is that almost everything hangs off M-$:

• M-$ (jinx-correct) - correct the nearest misspelled word
• C-u M-$ - correct all the misspellings in the buffer, one after another
• C-u C-u M-$ (jinx-correct-word) - correct the word before point, even if Jinx doesn’t consider it misspelled
• C-M-$ (jinx-languages) - switch the languages for the current buffer

When point is on a misspelled word a few extra bindings light up (those are the overlay-map bindings I mentioned earlier):

• M-n (jinx-next) and M-p (jinx-previous) - jump to the next/previous misspelling. They also set up a repeat map (provided you’ve enabled the built-in repeat-mode), so after the first jump you can keep going with just n and p, and press $ to correct the word you’ve landed on.
• mouse-3 (a.k.a. right click) - pops up a menu with the corrections. (Flyspell used mouse-2 for this, which always clashed with the default mouse yank)

The correction minibuffer has a few tricks of its own:

• 1 to 9 select the corresponding suggestion right away
• M-n and M-p move to the next/previous misspelled word without leaving the minibuffer - super handy in combination with C-u M-$
• below the suggestions you’ll find entries for saving the word, prefixed with @ (personal dictionary), * (file-local), / (directory-local) and + (just for the current session)

This is how correcting a word looks with vertico (note the numbered quick select keys and the squiggly underlines on the remaining typos):

If your Flyspell muscle memory is strong, here’s how the old bindings map to the new ones:

• M-$ (ispell-word) is still M-$ - that was the whole point of the binding in my setup
• C-, (flyspell-goto-next-error) becomes M-n
• C-c $ (flyspell-correct-word-before-point) is also covered by M-$, as correcting a word and saving it to your dictionary live in the same menu
• C-. and C-; (the auto-correct commands) have no direct equivalent - Jinx always takes you through the correction minibuffer, although the numeric quick-select keys make that almost as fast

Note: Dropping Flyspell also frees up C-. and C-;, which happen to be prime keybinding real estate. In my setup they are now bound to embark’s embark-act and embark-dwim, but that’s a topic for another article.

Closing Thoughts

Funny enough, I knew about Jinx for quite a while, but I kept using Flyspell mostly because of inertia. I guess old habits die hard! Now that I’ve finally made the switch, I can’t help but wonder what took me so long.

Have you tried Jinx already? Are you still happily using Flyspell (or something else entirely)? I’d love to hear your thoughts in the comments!

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

Thought my Emacs init file needs a bit of cleaning - it contains configs from maybe 5 and 6 years ago. It’s a nostalgic learning experience. More fun than I thought. More to come soon 🤓

Marcin Borkowski (mbork) has a nice post on the Jinx spell corrector. Mbork has tried fly-spell but found it too laggy for his purposes. That was back in the days when he had a Pentium class machine running at 100 Mhz so he thought, in view of his more modern hardware, that it was worth trying out fly-spell again.

He still found it too slow and decided to try Jinx instead. I’ve always found fly-spell snappy and I hadn’t heard of Jinx until I read Prot’s post on writing (and spell correcting) foreign languages in Emacs but mbork wasn’t satisfied until he tried Jinx. He found that it was fast enough for his use cases and decided to embrace it as his spell corrector.

He discovered that Jinx interfered with some of his work flows but it turned out to be pretty easy to fix those. You can check out mbork’s post for the details.

If you are writing in multiple languages with Emacs, then Jinx may be an excellent solution as a spell checker. If, like me, you mostly write in your native tongue, you’ll probably find fly-spell is all you need. As I said above, it’s more than fast enough for me and provides a wonderfully interactive spell correction system.

The word Gantt tends to evoke project-management software with bars you can drag and a hefty license fee. The underlying idea, tasks arranged on a horizontal timeline, with owners and effort estimates, is much older and much simpler than the software around it. It is basically a chart. You can draw one with a pencil and a string for a plumb line.

Org mode already stores everything you need for a Gantt chart: a hierarchy of tasks, SCHEDULED and DEADLINE timestamps, properties for Effort and assignments to various agents. What’s missing is the picture. But org can draw the picture too. Let’s take a look and, one hopes, save you a subscription fee.

* Draft chapter 5
SCHEDULED: <2026-02-12 Thu> DEADLINE: <2026-02-26 Thu>
:PROPERTIES:
:AGENT:    Chris
:Effort:   10
:END:

* Edit chapter 4
SCHEDULED: <2026-02-10 Tue> DEADLINE: <2026-02-20 Fri>
:PROPERTIES:
:AGENT:    Chris
:Effort:   6
:END:

* Design cover art
SCHEDULED: <2026-02-15 Sun> DEADLINE: <2026-03-01 Sun>
:PROPERTIES:
:AGENT:    Maya
:Effort:   8
:END:

(require 'org)
(require 'ox-html)   ; for org-html-encode-plain-text

(defun org-fas-gantt--collect ()
  "Return a list of task plists from the current Org buffer.
Only headings with both a SCHEDULED and a DEADLINE timestamp
are included.  :start and :end are absolute day numbers so
they are cheap to subtract."
  (delq nil
        (org-map-entries
         (lambda ()
           (let ((start (org-get-scheduled-time (point)))
                 (end   (org-get-deadline-time (point))))
             (when (and start end)
               (list :title  (org-get-heading t t t t)
                     :agent  (or (org-entry-get (point) "AGENT") "Unassigned")
                     :effort (org-entry-get (point) "Effort")
                     :start  (time-to-days start)
                     :end    (time-to-days end))))))))

(defun org-fas-gantt--bar (task day0 span)
  "Return one HTML row for TASK, scaled against DAY0 across SPAN days."
  (let* ((left  (* 100.0 (/ (float (- (plist-get task :start) day0)) span)))
         (width (max 1.0 (* 100.0 (/ (float (- (plist-get task :end)
                                               (plist-get task :start)))
                                     span))))
         (effort (plist-get task :effort)))
    (format (concat "<div class=\"row\"><span class=\"label\">%s</span>"
                    "<span class=\"track\"><span class=\"bar\" "
                    "style=\"left:%.1f%%;width:%.1f%%\" title=\"%s\"></span>"
                    "</span></div>")
            (org-html-encode-plain-text (plist-get task :title))
            left width
            (if effort (format "Effort: %s" effort) ""))))

(defun org-fas-gantt-render-to-html (&optional file)
  "Render the current buffer's Gantt tasks to FILE as HTML.
Interactively prompts for the output file.  Returns the file name."
  (interactive)
  (let* ((tasks (org-fas-gantt--collect))
         (file  (or file (read-file-name "Write Gantt HTML to: " nil "gantt.html"))))
    (unless tasks
      (user-error "No tasks with both SCHEDULED and DEADLINE found"))
    (let* ((day0 (apply #'min (mapcar (lambda (tk) (plist-get tk :start)) tasks)))
           (dayN (apply #'max (mapcar (lambda (tk) (plist-get tk :end)) tasks)))
           (span (max 1 (- dayN day0)))
           (agents (cl-remove-duplicates
                    (mapcar (lambda (tk) (plist-get tk :agent)) tasks)
                    :test #'equal :from-end t)))
      (with-temp-file file
        (insert "<!DOCTYPE html><html><head><meta charset=\"utf-8\">\n"
                "<style>\n"
                "body{font-family:sans-serif;margin:2rem;color:#222;}\n"
                "h2{border-bottom:1px solid #ccc;margin-top:1.5rem;}\n"
                ".row{display:flex;align-items:center;margin:.25rem 0;}\n"
                ".label{width:16rem;font-size:.9rem;padding-right:.5rem;}\n"
                ".track{position:relative;flex:1;height:1.2rem;background:#f0f0f0;border-radius:3px;}\n"
                ".bar{position:absolute;top:0;height:100%;background:#4a7;border-radius:3px;}\n"
                "</style></head><body>\n"
                "<h1>Project timeline</h1>\n")
        (dolist (agent agents)
          (insert (format "<h2>%s</h2>\n" (org-html-encode-plain-text agent)))
          (dolist (task tasks)
            (when (equal (plist-get task :agent) agent)
              (insert (org-fas-gantt--bar task day0 span) "\n"))))
        (insert "</body></html>\n"))
      (message "Wrote %s (%d task%s)" file (length tasks)
               (if (= (length tasks) 1) "" "s"))
      file)))

If this post saved you a SaaS subscription or two, consider tossing a few dollars in the tip jar. It goes straight back into writing more of these.

The post Org mode as a gantt chart generator appeared first on Chris Maiorana.

#TIL that #Emacs also has a Global Mark Ring:

the global mark ring records a sequence of buffers that you have been in, and, for each buffer, a place where you set the mark

For programming buffers / projects, I've been using the xref stack to go back/forward when jumping around. But the global mark ring is super useful as a general purpose tracker of my context jumps.

By default, C-x C-<SPC> jumps back. There is no forward like xref-go-forward, but it' a ring so it's possible to go around. Or there's always consult-global-mark to show the marks in a list and select from it.

Other helpful links:

• Emacs: Mark Ring by Arialdo Martini
• Efficiency With The Mark Ring by Vernon Grant

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

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

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

Below are the release notes.

Version 1.2.0 on 2026-07-12

Two new themes

doric-tiger is a light theme, while doric-lion is dark. Both have warm colours.

Org agenda events are easier to spot

Events are entries which have an active timestamp but not a SCHEDULED or DEADLINE keyword associated with it. Those are now rendered in italics in addition to the faint foreground they already had (the faint foreground is there because an event is not as important as a

Support for vc-dir-key-binding-hint-label (Emacs 32)

This concerns a new option for VC Dir buffers to display their available key bindings. The face applies to the additional headings. They should now look like all the other headings in those buffers in the interest of stylistic consistency.

Some package.el faces stand out more

Those are present in the buffer that M-x list-packages produces. They concern certain status indicators and fit in better with the rest of the design.

The nobreak-space face is now underlined

This is one way to make that character visible. It is useful to know that a space is not the regular space. For example, in French orthography we are expected to include non-breaking spaces between the quotes and the words like « Protesilaos ». Whether you actually follow that guideline is another discussion—I happily ignore it.

If you’re an Org user, you probably know that you can assign a priority to TODO items. By default, the priorities are A, B, and C but with a bit of trickery you can extend the ranges to 0–9 and A–Z.

I never use priorities but Raymond Zeitler does and after figuring out the above trickery he thought it would be useful to have an ultimate priority a sort of “drop everything and do this immediately” priority. He decided to make this priority 100 times the highest priority and to designate it with !.

The solution wasn’t straightforward but it wasn’t too difficult either. The thing about Emacs is that it’s easy to check the source code to see how things are done. It turns out that Org has a org-priority-get-priority-function variable that contains a function that Org calls to get the priority from the priority cookie. Zeitler wrote his own version to check for a ! and return the high priority if it’s found. If not, then it calls a slightly modified version of the normal function.

As I say, I don’t make use of the priority mechanism and have no idea how many people do but if you’re one of them and are looking for a way to specify an extraordinary priority, take a look at Zeitler’s post. You can cut and paste his code if you’re interested.

The problem

My email setup is the usual text based machinery I keep writing about: Mu4e with mu, isync (mbsync) and msmtp. It works beautifully – until one day it did not.

When I moved emails around in Emacs – with mu4e-headers-mark-for-move, mu4e-headers-mark-for-refile or other command – the date of the moved email changed. A mail from last March would suddenly float to the top of the mailbox as if it had just arrived.

The diagnosis

The Date: header inside the message is never touched – that is why Mu4e always looks correct, it shows the date parsed from that header.

What changes is the arrival date: the IMAP “internal date” the server stores separately from the body. That is what Mail.app shows and sorts by (“Date Received”).

The culprit is this setting, which I need to avoid duplicate-UID errors with mbsync:

(setq mu4e-change-filenames-when-moving t)

With it on, Mu4e does not just move the file on refile – it rewrites the message as a brand-new Maildir file, as if freshly delivered, resetting its arrival time to now. mbsync then pushes that up and the server stamps the new internal date. Mail.app is exempt because it moves server-side via IMAP MOVE, which preserves the internal date.

First fix: CopyArrivalDate (necessary, not sufficient)

The fix lives in mbsync, not Emacs. In ~/.maildir/mbsyncrc, once at the top so it applies to every channel:

CopyArrivalDate yes

This propagates the arrival time with the message instead of letting the server stamp a fresh one. But on its own it was still wrong – because mbsync reads that arrival time from the file’s modification time (mtime), and Mu4e already reset the mtime to now when it rewrote the file. So CopyArrivalDate faithfully copies the wrong value.

The real fix: restore the mtimes before syncing

I keep mu4e-change-filenames-when-moving at t and, right before each sync, walk the Maildir, read each message’s Date: header, and set the file’s mtime to match. Then CopyArrivalDate yes carries the correct value up.

Thank god for Claude Code for the help with the Python script.

~/.maildir/fix-maildir-mtimes.py:

#!/usr/bin/env python3

"""Restore Maildir mtimes from each message's Date: header, so that
mbsync's CopyArrivalDate propagates the correct received date."""

import os
import sys
import time

from pathlib import Path
from email.parser import BytesParser
from email.utils import parsedate_to_datetime

maildir = Path(os.path.expanduser(sys.argv[1] if len(sys.argv) > 1 else "~/.maildir"))
window  = float(sys.argv[2]) if len(sys.argv) > 2 else 2 * 86400
cutoff  = time.time() - window if window else 0

for f in maildir.rglob("cur/*"):
    try:
        st = f.stat()
        if window and st.st_mtime < cutoff:
            continue
        with open(f, "rb") as fh:
            msg = BytesParser().parse(fh, headersonly=True)
        dt = parsedate_to_datetime(msg.get("Date"))
        if dt is None:
            continue
        ts = dt.timestamp()
        if abs(st.st_mtime - ts) > 1:
            os.utime(f, (ts, ts))
    except Exception:
        continue

Wrapping it in front of mbsync

Rather than hooking “into” mbsync, I put a wrapper in front of it. This is ~/.maildir/sync-mail.py (yes, the .py on a bash script is a small lie – it started life in Python):

#!/usr/bin/env bash

~/.maildir/fix-maildir-mtimes.py "$HOME/.maildir"

exec mbsync "$@"

The fixer runs against the whole ~/.maildir root, covering every account in one pass. $@ is forwarded straight to mbsync, so I can pass a single channel name or --all. Make both files executable:

chmod +x ~/.maildir/fix-maildir-mtimes.py ~/.maildir/sync-mail.py

Hooking it into Mu4e

Mu4e simply runs whatever is in mu4e-get-mail-command, so I point that at the wrapper. By default it syncs everything:

(customize-set-variable 'mu4e-get-mail-command
                        (concat (executable-find "~/.maildir/sync-mail.py") " --all"))

And for the times I want to sync a single account, timu-mu4e-get-mail lets me pick it first:

(defun timu-mu4e-get-mail ()
  "Select the Account before syncing.
This makes the syncing of mails more flexible."
  (interactive)
  (let ((mu4e-get-mail-command
         (concat
          "~/.maildir/sync-mail.py "
          (completing-read
           "Which Account: "
           '("icloud" "aimebertrand" "moclub" "--all")))))
    (mu4e-update-mail-and-index t)))

(keymap-set mu4e-headers-mode-map "M-r" #'timu-mu4e-get-mail)
(keymap-set mu4e-main-mode-map    "M-r" #'timu-mu4e-get-mail)
(keymap-set mu4e-view-mode-map    "M-r" #'timu-mu4e-get-mail)

Because sync-mail.py runs the fixer before exec mbsync, every sync I trigger with M-r repairs the dates first – asynchronously, so Emacs never blocks. If you also sync outside Emacs (cron, launchd, a terminal), point those at sync-mail.py too, or a background sync could re-clobber a freshly moved message.

Conclusion

Three moving parts: CopyArrivalDate yes in mbsyncrc, fix-maildir-mtimes.py to restore the mtimes, and sync-mail.py wrapping both as the single entry point behind mu4e-get-mail-command.

Two honest caveats: it only fixes messages going forward – already-moved mails keep their overwritten server date – and some servers may stamp their own date on upload regardless. For my mailboxes it works wonderfully though. Yeah!!!

In the previous post,¹ I was disappointed to learn that valid priority characters are limited to 0–9 and A–Z. I thought it would be neat if the exclamation mark ("!") could represent the ultimate priority, a sort of "drop everything and do this immediately" kind of priority.

It turns out that you can use "!" for this purpose, regardless of which priority characters you've configured. The trick is to write a function and assign it to org-priority-get-priority-function.

The function (which I named org-get-cust-priority) simply looks for "!" in the priority cookie and returns one hundred times the value that would be returned by the highest valid priority. If it doesn't find "!" it simply calls a modified version of the usual org-get-property function,² which I named org-get-std-priority. The two functions are shown below.³

(defun org-get-cust-priority (s)
  "Return 100 times the highest priority when S contains
a priority cookie with `!'.  Otherwise call the usual
`org-get-property' function. Intended to be assigned to
`org-priority-get-priority-function'."
  (interactive)
  (if (not (functionp org-priority-get-priority-function))
      (org-get-std-priority s)
    (string-match ".*?\\(\\[#\\(!\\)\\] ?\\)" s)
    (if (string-equal (match-string 2 s) "!")
        (* 100000 (abs (- org-priority-lowest org-priority-highest)))
      (org-get-std-priority s))))

(defun org-get-std-priority (s)
  "Find priority cookie and return priority.
S is a string against which you can match `org-priority-regexp'.
Same function as `org-get-priority' sans test for a custom
function in `org-priority-get-priority-function'."
  (save-match-data
    (if (not (string-match org-priority-regexp s))
        (* 1000 (- org-priority-lowest org-priority-default))
      (* 1000 (- org-priority-lowest
                 (org-priority-to-value (match-string 2 s)))))))

The number that Org uses to sort on priority depends on the values of org-priority-lowest and org-priority-highest,⁴ which are "C" and "A" by default. In the default configuration, the highest priority has a numeric value of 2000, while the lowest has a value of 0. If the highest and lowest priority characters are 1 and 9, respectively, the highest priority has a value of 8000.

You know you need this if you have about a dozen items on your agenda and half of them are prioritized A.

¹ https://ray-on-emacs.blogspot.com/2026/07/numeric-priorities-in-org-mode.html
² Modified just to prevent recursion.
³ I know this code isn't particuarly elegant. I could have made custom variables for "!" and the priority multiplier, for example. I'd like to use it for a while before deciding whether it's worth investing any more effort. I do welcome suggestions on how to improve.
⁴ Or rather, the difference between the highest and lowest priorities.

A common refrain is that Emacs is an operating system (OS). This isn’t true, but what invites comparison to an OS is its ability to orchestrate applications and utilities above the OS kernel level. The diagram below suggests a truer picture of how Emacs’ relates to an OS and its capabilities.

Emacs’ built-in access to OS system services (file system, network, etc.) coupled with the ability to run other programs makes it routine to improvise client behavior within it. Because of this, Emacs users are able to accomplish many of their computing needs from the different client modes that have been made for it. This gives credence to the notion of “living only in Emacs.”

In this post, we’ll examine some of the ways Emacs lets you build a client. By the end of this post, you’ll hopefully be convinced that from within Emacs, everything looks like a service.

Client-Server Model

Let’s first provide some definitions.

The Client–Server model is a common computer interaction pattern where a task is partitioned between the provider of a resource (the service) and the requester of that resource (the client). The client issues a request to the server, and the server in turn returns a response as shown in the diagram below.

Depending on the implementation, the transaction (request + response) can occur over a network or be local to a system. Client-server models using a network has been most elaborated upon with REST-style software architectures. Shown in the sequence diagram below is a common implementation pattern for REST-style client server architecture.

Emacs as a Client

From the diagram above, there are three concerns the client is typically responsible for:

• UI: User interface (if any).
• Client Edge: Sub-system concerned with communication with the service. For networked clients, this is the network sub-system.
• Local Database: Representation of data that is exchanged or synchronized with the server. How this data is managed is up to the implementation requirements.

For the above concerns, Emacs provides numerous libraries both built-in and third-party which can implement a client. Listed below are some built-in libraries with their respective links for further reading:

• UI

  • Minibuffers
  • Buffers
  • Completion
  • Tabulated List Mode
  • Variable Pitch Table (vtable)
  • Transient

• Client Edge

  • URL
  • Socket (TCP/UDP)
  • SMTP
  • Serialization/Deserialization
    • JSON
    • XML

• Local Database

  • Collections
    • Association Lists
    • Property Lists
    • Hash Tables
  • SQLite

Requirements dictate the amount of complexity required to implement the Emacs client. If there is an existing command line utility that can do the “heavy lifting”, said utility can be reframed as a “service” that can be accessed via a shell call.

Elisp

All the libraries mentioned above are accessed through the Emacs Lisp (Elisp) programming language. Elisp is a dynamic programming language which allows for a high degree of improvisation during run-time. This capability allows for complex orchestration of any behavior that is available to Emacs, from Elisp functions to shell commands.

Example wttr.in client

wttr.in is a console-oriented weather forecast web-service. It supports JSON output so we can build an Emacs wttr command which will prompt for a location, make the HTTP request, process the JSON response and display the result in the mini-buffer.

The top-level command wttr is shown below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

(defun wttr (location)
  "Show weather conditions for LOCATION from `https://wttr.in' in mini-buffer.

Result is also stored in `kill-ring'."
  (interactive "sWhere (default: local): ")

  (condition-case err
      (let* ((url (wttr--request-url location))
             (jsondb (fetch-json-as-hash-table url))
             (msg (wttr--report-message jsondb)))
        (kill-new msg)
        (message "%s" msg))

    (error (message "ERROR: %s" (cdr err)))))

The wttr.in URL is constructed by the function wttr--request-url shown below.

1
2
3
4
5
6
7

(defun wttr--request-url (location)
  "Construct wttr.in URL with LOCATION."
  (let* ((base-url (url-generic-parse-url "https://wttr.in"))
         (encoded-location (string-replace " " "+" location))
         (query (format "/%s?0&format=j1" encoded-location))
         (_dummy (setf (url-filename base-url) query)))
    (url-recreate-url base-url)))

We can subsequently pass that URL into fetch-json-as-hash-table which does the heavy lifting of retrieving the URL and parsing the JSON response into an Elisp hash-table.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

(defun fetch-json-as-hash-table (url)
  "Fetch URL with expected JSON response and return a `hash-table'."
  (let ((data-buffer (url-retrieve-synchronously url)))
    (if (not data-buffer)
        (error "Failed to fetch data from %s" url)
      (unwind-protect
          (with-current-buffer data-buffer
            ;; Move point past the HTTP metadata headers
            (goto-char url-http-end-of-headers)
            ;; Parse the remaining JSON buffer into a hash-table
            (json-parse-buffer :object-type 'hash-table))
        ;; Always kill the downloaded network buffer to prevent memory leaks
        (kill-buffer data-buffer)))))

Finally we can extract the desired values from the JSON response (jsondb) to populate the message that will sent to the mini-buffer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

(defun wttr--report-message (jsondb)
  "Generate weather report message from JSONDB."
  (let* ((area-buflist ())
         (nearest-area
          (wttr--get-first jsondb "nearest_area"))
         (area-name
          (map-elt (wttr--get-first nearest-area "areaName") "value"))
         (region
          (map-elt (wttr--get-first nearest-area "region") "value"))
         (country
          (map-elt (wttr--get-first nearest-area "country") "value"))

         (current-condition (wttr--get-first jsondb "current_condition"))
         (temp_c (map-elt current-condition "temp_C"))
         (temp_f (map-elt current-condition "temp_F"))

         (weather-description
          (map-elt
           (wttr--get-first current-condition "weatherDesc") "value")))

    (mapc (lambda (x)
            (if (and x (not (string-equal x "")))
                (push x area-buflist)))
          (list area-name region country))

    (format "%s: %s°C, %s°F %s"
            (string-join (reverse area-buflist) ", ")
            temp_c
            temp_f
            weather-description)))

wttr.el source

Closing Thoughts

At this point, hopefully you are convinced of the title assertion that from Emacs, everything looks like a service. Furthermore, many of the APIs offered by Emacs work at a high-level of abstraction. Consider that the lines of code for wttr.el weighs in at 67. (Result using the cloc utility.)

If that’s too much, then imagine an alternate implementation where the actual network request and JSON processing is done in a Python script called weather. Then the Elisp command to invoke it is just the code shown below.

1
2
3
4
5
6
7
8
9

(defun weather (location)
  "Call weather script with LOCATION and show result in minibuffer."
  (interactive "sWhere (default: local): ")

  (let* ((weather-cmd "weather")
         (cmd (if location (format "%s %s" weather-cmd location) weather-cmd))
         (result (shell-command-to-string cmd)))
    (kill-new result)
    (message result)))

With the above implementation, the shell command becomes effectively the “service” to make a request to.

As Elisp is a dynamic programming language, it can allow for integration of Elisp libraries with command line utilities in an improvised fashion.

This capability is compelling to users who recognize the opportunities it can offer.

It's been a while since I wrote for the Emacs Blog Carnival but I have missed it. I decided to dip my toes back in when I saw July 2026's theme - Programming.

I started thinking about how my Emacs configuration for development isn't that special and then I realized that the centerpiece of my environment, direnv and Nix, is something that is worth talking about. I have a whole post on setting them up so this will continue with what that post glossed over: How does this work with Emacs?

The idea started off with the fact that I don't want separate configurations for my CLI and Emacs. I want to just configure it once and things will just work in both. Since getting my shell to see my Emacs configuration seems like a waste of time, I chose to let Emacs read what the shell was doing. What I ended up with is my system-wide Emacs reading the same configuration that my shell does, and then by default, Emacs uses the same paths and interpreters. I don't need a .dir-locals in any project folders to set special paths. It just works.

The center of this is the envrc package. It runs direnv when each buffer is opened so you have the right configuration when you need it. I don't think the envrc maintainers sought to support Nix in their package, but because it supports everything direnv does seamlessly, it supports Nix by default.

The envrc configuration in Emacs is easy:

(use-package envrc
  :hook (after-init . envrc-global-mode))

Then I make sure I set up my .envrc and shell.nix files like I did in my old post and then make sure I run direnv allow and… that is it. Whenever I open up a file in that project after that inside Emacs, envrc will setup the environment automatically. It finds the right interpreter, LSP engine, etc. I don't have to do anything.

This is especially powerful for LSP. This is an actual shell.nix file for an old Python project I maintain:

{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = [
    pkgs.python311
    pkgs.poetry
    pkgs.basedpyright
  ];


}

I install the LSP server – Basedpyright in this case – within the project instead of globally. That way I know that it has the right version of Python and can get its dependencies and then Eglot starts up just fine. When I need to work on this project, I just cd ~/Projects/project-a and then my shortcut for helm-projectile-switch-project and choose the project folder in Emacs.

For completion's sake, here is the .envrc for the same project:

use nix

The magic is that this is all local to the buffers. I can have two projects open at once, each pinned to a different Python, and Emacs just does the right thing in each.

So in project-a it looks like:

;; a buffer under ~/Projects/project-a
M-! which python
/nix/store/j0r98nqnq891c08q2dns661qnz42fz49-python3-3.11.15-env/bin/python

Then I switch to project-b

;; a buffer under ~/Projects/project-b
M-! which python
/nix/store/jn7s7larin2h9yz8fn9g0zkz5asg8i4d-python3-3.13.12-env/bin/python

Same Emacs, same command, two different interpreters because I'm in buffers in two different projects. I never touched exec-path or dropped a .dir-locals.el in either project. Each buffer is running under its own project's .envrc. Of course if I add environment variables to my .envrc file or change that in any way, I have to do another direnv allow in that folder, or in Emacs run envrc-allow in a buffer in that project.

On the other hand, I can change the shell.nix file as much as I want and it will be automatic when I reload the buffer.

Both my shell and Emacs use the same configuration, and I don't even think about it anymore. It just is so seamless and automatic.

Org mode is configured "out-of-the-box" with these three levels of priority: A, B, C, where A is the highest priority. However, this can be changed. You can use numbers to indicate priority, such as 1 (highest) to 10 (lowest) as shown in the documentation.¹

If you specify priorities from 65 to 90, Org will interpret the numbers as ordinal values of ASCII characters and give you "A" to "Z." If you try to be clever and specify priorities as 65 to 91 (91 is the decimal ASCII code for left square bracket character) you'll be disappointed that when you lower the priority from "Z," you don't get "[." (I was disappointed, anyway.)

You can define priorities from 10 to 99, for example. But if you try to get to a priority higher than 10 using org-priority-up, Org will clear the priority cookie. However, you can manually enter a priority of 0 to ensure the item appears above all other items. (Please see Figure 1, below.) Thus, a priority value of 0 can be your "stat" item. It would be super neat if Org could understand that ASCII characters below 0 (such as the exclamation mark) are an even higher priority than 0. Unfortunately, it doesn't even recognize [#!] as a priority cookie.

A large priority span seems like it would be useful. For example, you might have all utility bills set from 50 to 59, and shopping for birthday or anniversary gifts from 10 to 19. However, in order to go from a priority of 50 to 10, you'd have to press the Up Arrow key forty times. If you think you can invoke M-4 0 M-x org-priority-up to go quickly from 50 to 10, you'll be disappointed (again). The function org-priority-up doesn't accept a prefix argument.²

How do you use priority in Org?

¹ Org Manual -- Priorities

² But you can record a macro that consists of a single S-<up> key press and then play it back with a prefix argument of 39.

Although I primarily use Emacs, I love the idea of vim text objects, and wanted to incorporate them into my editing. The Kakoune introduction explains that vim uses verb first, noun second for its commands, whereas Kakoune uses noun first, verb second. I wrote a blog post about why I prefer noun-verb over verb-noun, not only in text editors but also in games and other applications.

I started cobbling together some commands in a hydra, trying to match vim keys when I could:

(defhydra hydra-mark (:body-pre (set-mark-command nil) :color red)
  "
_w_, _,w_: word, symbol    _i'_, _a'_: string  _i)_, _a)_: pair
_t_, _f_: to char (exclude/include)   _0_, _$_: begin/end of line
_;_: comment   _u_: url    _e_: email      _>_: web-mode block or tag
_S_: sexp      _d_: defun  _p_: paragraph  _s_: sentence
_h_, _j_, _k_, _l_: move   _H-._: off
  "
  ("t" mark-to-char-exclusive)
  ("f" mark-to-char-inclusive)
  ("0" move-beginning-of-line)
  ("$" move-end-of-line)
  ("w" er/mark-word)
  (",w" er/mark-symbol)
  ("i'" er/mark-inside-quotes)
  ("a'" er/mark-outside-quotes)
  ("i)" er/mark-inside-pairs)
  ("a)" er/mark-outside-pairs)
  ("i]" er/mark-inside-pairs)
  ("a]" er/mark-outside-pairs)
  ("j" next-line)
  ("k" previous-line)
  ("h" left-char)
  ("l" right-char)
  (";" er/mark-comment)
  ("u" er/mark-url)
  ("e" er/mark-email)
  ("d" er/mark-defun)
  ("S" mark-sexp)
  ("s" mark-end-of-sentence)
  ("p" mark-paragraph)
  (">" web-mode-mark-and-expand)
  ("H-." deactivate-mark :exit t)
   )
(defun my/hydra-mark ()
  (interactive)
  (set-mark-command nil)
  (hydra-mark/body))

(bind-key "H-." #'my/hydra-mark)

(defun move-to-char (arg char)
  (interactive (list (prefix-numeric-value current-prefix-arg)
                     (read-char "Move to char: " t)))
  (search-forward (char-to-string char) nil nil arg))

(defun mark-to-char-exclusive (arg char)
  "Mark up to but not including ARGth occurrence of CHAR."
  (interactive (list (prefix-numeric-value current-prefix-arg)
                     (read-char "Mark to char: " t)))
  (set-mark
   (save-excursion
     (move-to-char arg char)
     (backward-char)
     (point))))

(defun mark-to-char-inclusive (arg char)
  "Mark up to and including ARGth occurrence of CHAR."
  (interactive (list (prefix-numeric-value current-prefix-arg)
                     (read-char "Mark to char: " t)))
  (set-mark
   (save-excursion
     (move-to-char arg char)
     (point))))

(use-package expand-region) ;; for the er/* commands

I've been using this since 2017. It's now 2022. How did it go?

Old habits are hard to break. I used this for urls, words, strings, almost none of the others. It's easier for me to move the cursor manually than to learn the specific commands, unless the command is something I use often.

So I'm going to call this experiment complete. I learned that it it's not going to work for me. That's ok. I try lots of things and most don't work. Some do, which is why I keep trying.

I still think the idea is good but I have 30 years of emacs muscle memory to fight.

I considered switching to one of these:

• mark-thing-at lets you define keys for marking each type of thin
• objed lets you work on text objects, inspired by vim and kakoune
• expand-region will guess the object instead of making me choose

I decided I'll remove my experiment code and try expand-region next. [update 2025-05: gave up on expand-region in general, as I only use mark word or url, so I wrote something specific to that.]

• [2025] also see https://github.com/alexispurslane/motion-selection-mode
• [2025] also see https://github.com/alexispurslane/motion-selection-mode
• [2025] also see https://github.com/alexispurslane/motion-selection-mode
• [2026] also see https://github.com/alexispurslane/motion-selection-mode

Protesilaos Stavrou (prot) has an excellent video that addresses a problem I often see people asking about. The problem is how to globally set a key binding so that it won’t be overridden. He uses setting Meta+o to other-window as an example to explore the problem.

Prot begins by defining Meta+o in the global map in the usual way:

(define-key global-map (kbd "M-o") 'other-window )

That works well until he tries it in an HTML buffer. In the HTML buffer, Meta+o turns out to be a prefix key for inserting an HTML face command. The problem is that Emacs will use the most specific bindings first. Global bindings are the most general, followed by major mode bindings, and ending with minor mode bindings as the most specific.

Since HTML is a major mode, its keybinding take precedence over the global binding that we set. The answer is to get more specific yet by defining our binding in a minor mode so that it will always have precedence.

Prot shows how to define a minor where we can define our binding and activate it globally so that it’s always available. Of course, once we have this mechanism set up, we can add any number of bindings to our minor mode. Prot demonstrates this by adding a binding that Org uses.

Take a look at Prot’s video for all the details. He’s also included a copy of the file he was working with so you can see everything without worrying about copying it down from the video. The video is 12 minutes, 45 seconds so it should be easy to fit in.

Karthik Chikmagalur suggested that we chat with John Wiegley to find out about the interesting things he's been doing with Org Mode. It was a really cool look at a heavy-duty workflow that dealt with thousands of open items. Since John was sharing his actual Org files instead of a simplified toy example, there was a fair bit of redaction to do. I got all the way to redacting these screenshots, but my brain didn't want to get around to figuring out how to redact the information in a live video where John was scrolling around and stuff. Instead of waiting for either me or Karthik to figure that part out someday, we figured we'd just post the audio, the transcript, and the screenshots. Here you go!

Transcript and screenshots

Expand this for the transcript and screenshots

0:00 Getting set up with Zoom, chatting

Sacha: Recorded. There you go. Fantastic. Karthik was just telling me that you and Karthik have been having cozy chats on Discord about all the cool things you've been doing on the road.

John: That's right.

Sacha: Here we are.

Karthik: Okay. Hi, John.

John: Hey there, Karthik.

Sacha: Okay, I'm going to figure this out. There's probably a gallery view that I can use to show everybody on screen. Sorry, Zoom is—

John: That little nine-boxes icon in the upper right should give you that option.

Sacha: Nine boxes. I'm not seeing it. Nine boxes.

John: Oh, you might be on a Linux machine. I don't know how it works.

Karthik: It says "view." For me, it's a button on the top right that says "view."

Sacha: I'm just on the little screen and I'm in the web browser, so I don't see it. But I'm going to leave and I'll come right back.

John: Okay. It's been a while since we've seen each other in person, Karthik. How's the new job?

Karthik: Oh, it's busy. It's getting busier and busier. Just managing this two hours in the afternoon today was quite a deal.

John: Oh, I'm sorry to have been late. I did not mean to.

Karthik: Oh, no, no, it's fine. I'm glad we can finally capture your amazeballs Org setup.

John: We'll see what we can cover.

Karthik: So yeah, roughly speaking, I want to spend half an hour where you just show the various things you do with Org and how you use it to track your life. The other half hour, I'm going to badger you with philosophical questions about what it means to track your life.

John: Okay, that sounds fair.

Karthik: Right? Where Org will be a participant but not the focus. That's kind of my plan, but I'm going to let Sacha take it away because she's the consummate interviewer here. I will pipe in with questions. That's the plan. Okay, can we check if you can share your screen, your Emacs window, because I imagine we'll be seeing that a lot. Let me see here. My Emacs window. Okay.

2:34 Increasing font size globally with C-x C-M-=

Karthik: John, could you increase the font size by a little bit? Because I'm imagining people watching this on YouTube. I'm going to end up having to do that a lot.

John: I don't know how to do it globally.

Karthik: I can tell you. Get your fingers warmed up because it's C-x C-M-=.

John: Yeah.

Sacha: And then—okay. Yes, all right.

John: Wow, look at that.

Karthik: And then you can just keep pressing equals to keep increasing it.

John: So which size? Is this size good?

Karthik: Yeah, this size. Sacha, do you think this is big enough?

Sacha: It looks great. It looks fine to me. Let's give it a try.

John: It's going to be a lot of text to blur out, Karthik.

Sacha: Do you want it bigger?

Karthik: I can draw big windows in the video editor.

3:47 Redacting information when sharing Org demos

Sacha: I guess someday we will fix this with some kind of redaction global minor mode that just replaces everything with plausible-sounding text. I have something like that locally—it just replaces email addresses and phone numbers and stuff. But yes.

John: I wonder if Sora could do that actually to the whole video.

Karthik: You would be sharing all your data.

John: Oh, that's true. Never mind.

Sacha: One thing that we were talking about before is you could also consider sharing the transcript and then either screenshots or short clips, because that way we can just focus on the parts that demonstrate the workflow that you've developed without necessarily having to edit every single frame to make sure that everything is always covered.

John: Sure. Yes.

4:41 Daily Org Mode workflow for handling 40,000 entries

Sacha: So thank you for joining me and Karthik. I'm looking forward to finding out about all the cool things that you've been developing in your Org-mode workflow over the past two years since our last conversation about Org and personal information management. So what does your daily Org workflow look like now?

John: I've actually evolved several different tools on top of Org-mode itself. Now that we're in 2026, I have just under 40,000 Org-mode entries in my system. About 9,700 of those are tasks, and right now there are something like 1,200 of those tasks that are open. So my whole system is meant now to help me pay attention to what I need to pay attention to, because there's too much information. I could never, even if I wanted to, review it all or even just browse through it all. So Org-mode has to be the one to really condense everything into lists that are appropriate for when I'm working and what I'm working on. That's kind of the object of all the different things that I have: how do I make use of this sea of data? And I'm sure there's a whole bunch of stuff in my life that isn't even captured yet. That's the real rub here— despite this complexity, it's not that there's too much complexity, it's that there's not even enough yet. There are still things that live only in my mind, and as much as I can, I try to move them from my mind into Org-mode. But then I need to have Org-mode show it to me when I need to see it. Otherwise, it's no better than my memory.

6:24 Outlines for Focus and Home

John: When I first go into Emacs, I always see these two pages. I use Org-roam on top of Org-mode in order to move tasks and notes into separate Org-mode files and have those be interlinked and organized well. I interlink everything by ID, which is sort of an Org-roam philosophy, and I've taken that on. I come into the focus page on the left, which is all of the stuff that I want to focus on project-wise right now. Every heading should either be a link to the project that the focus is about, or if I go ahead and look at the body of one of these entries, it will be a column view that pulls in a report— basically an embedded report for that category. I use categories a lot, and I use projects a lot, where projects are hierarchies that contain tasks, and categories are just names that might cut across many, many tasks. I also use tags, but tags are a whole separate thing that doesn't have to do with this.

7:34 Column view

John: So anyway, you can see here a column view— this is a special version of column view. It's based on org-ql in order for it to be fast enough, but this column view doesn't exist out in the wild. This is in my own private dot-emacs repository. I wrote an org-ql column view function. Of course, it's very customized to my data format, but I have a :who field, and if you put a word here, that means if this shows up as either a category or a tag, then include that item in the report. Then I want it to sort by column three, and column three here ends up being the tags. That way I can see things sorted by tag. Anyway, each of these is linked to the corresponding issue by identity. So if I just do C-c C-o, then it will take me over to that item in that Org-mode file—that Org-roam file, sorry. So that's the purpose of the focus file: I can have a 10,000-foot overview of what I'm currently working on and what I want to focus on.

8:44 Home is a collection of links

John: Then on the right is the homepage. This homepage basically is a collection of links, kind of like Linux utilities such as Glances or Cockpit— something that allows you to have one page that you jump to all kinds of different things from. This is my jumping-off page to a bunch of other pages that themselves serve as indexes within my Org-mode/Org-roam repository. This way I don't have to remember, "Oh yeah, how did I get to such-and-such a project?" I can just look in—it's a bookmarks list, but it's a meta-bookmarks list.

9:22 C-c C-o opens one or all links in the Org Mode entry

John: The other nice thing about Org-mode is that if you're on an entry that has links inside the entry like this one does, and you do C-c C-o, it'll show you all of the links, and then you can hit return to open them all.

9:38 Example: Claude settings.json on multiple machines

John: This way, what I do in the homepage is, I have a whole bunch of settings files for Claude because I use Claude in a lot of different places. I have different accounts and I have different machines and different accounts on those machines. Sometimes I need to make an edit to every single one of those files but I don't want to have to remember how to open up each one. Even an Emacs bookmark wouldn't be quick enough, but if I have the whole list of links as I do here in my Org-mode file, then I can just C-c C-o RET and it will open all of these in my browser at once. I do this a lot to open sets of pages when I need to do bulk editing in the browser or even in Emacs because, as you know, with the right add-ons, Org-mode links can be empowered to open all kinds of different things. I have Org-mode links that jump to Magit status pages for different projects in Git. I have ones that open dired buffers. I have ones that open Gnus, all kinds of different apps. I navigate to these through Org-mode links. In this way, Org-mode becomes the master dashboard of my information ecology. Yeah, so... go ahead.

Sacha: No, no. So to recapitulate: instead of using a gazillion agendas where you have to remember the keystrokes to open each custom agenda, you use Org-mode outlines in your focus and your homepage that have links to or reports for the different things that you're focusing on.

John: Yes, but not instead of. I also use tons of Org-mode agenda links as well. But Org-mode agenda links have a very specific focus. Usually when I start the day, when I start Emacs, I come to these two pages. I've set it up so that after startup, it always shows me these two pages. But usually the first thing I do is hit C-c a a to go to my agenda for today.

11:41 org-super-agenda is divided into topical categories

John: I use org-super-agenda to divide this into categories— not category categories, but topical categories— so that I can see things segregated by which are the high-priority items, which are the things that are currently in progress, and then if they have a context where they need to happen (phone calls, errands, blah blah blah), then I see them all. This is just one of the agenda reports I use; this is the daily report. If I look at my agenda here, you can see I have the standard agenda reports, but then I have subcategories. I have a whole set of org-ql-powered agenda queries. If I look at these, I can look at all my open-source tasks, all my work tasks.

Sacha: Your screen is shifted sideways for me. I'm not really sure.

Karthik: Same here. So it's a little bit on the left. You may need to reshare your screen.

John: That's weird. I've never seen that happen before.

Sacha: So you've got your agenda.

John: I'm sharing a process window.

Sacha: Okay, here we are. Yes, I see it now. Okay, so these are the other things you've got.

12:54 Org-ql filters tasks

John: These are basically queries that I have created for org-ql, and then the tasks-for that mirrors that org-ql column view "who tag" where I can give something that will match either a category or a tag,

John: and it will show me here in the org-agenda report the same information it would have shown in that org-ql column view report.

13:20 Other agenda reports help review tasks

John: I also have different reports in the agenda for reviewing my tasks, and I'll have to come back to that because that's a big part of this whole process as well.

13:29 Custom reports identify things that need to be filed

John: Then at the bottom, you can see I have other custom reports for seeing things that haven't been filed— they're in my inbox, they need to be filed away.

13:37 I keep files in a flat directory and use search instead of categorizing files

John: I do like to file tasks in the file system. I've lost the battle of introducing any kind of structure because I just have too many files. My database on functional programming alone now has over 10,000 PDFs in it. I just can't categorize those. So they're all in one flat directory, and I search for them by using AI and by keyword search, because that's all I really can do. But for Org-mode, I haven't given up on having a hierarchy to my data. That's still helpful.

14:14 Make meaningful distinctions

John: By the way, we're going to talk philosophy in a little bit, but I will say that all the decisions I make about which reports to create, which tags to create, which categories to create, are driven by a philosophical principle which I call meaningful distinctions. We all interact with basically an uncountably large sea of information, and part of our job as knowledge workers is to impose criteria on that information so that we can make distinctions and say, "Okay, this relates to this, this relates to this." But there's all kinds of stuff we could be doing in making those distinctions, and not all of them are meaningful. Sometimes we spend energy— and all maintaining distinctions takes energy, because first you have to do it and then you have to maintain it. So it's very, very important to economize the work you spend making distinctions. I economize by trying to answer the question: is this distinction meaningful? What makes a distinction meaningful to me is that I use it in some way. It either has to help me in my job of maintaining focus on the appropriate information, or it has to help me with finding information. If it's not doing one of those two things, there's no reason to have the distinction. Even if a distinction screams out loud, "Hey, there's a distinction between your wife and your mother-in-law!"— does it matter that I draw that distinction? Probably not in most cases. So I have a "family" group rather than distinguishing those two people. Do I need to distinguish between all my co-workers? Probably—those are all distinctions that have some kind of meaning, but they're not meaningful to the purpose for which I use Org-mode, which is to assist my focus. So it's really important to know what you want Org-mode to do for you in order to make good use of Org-mode, especially at scale.

16:08 Color indicates agenda category

Sacha: I noticed one of the things that's changed since I last saw your agenda is now you're using color to make a lot of things more salient. So how do the colors in your agenda kind of build on the distinctions that you're making?

John: The colors here are based on category. I also show the category in words on the left because many categories share colors. Everything that's personal is one color, everything that's work-related is another color, everything that's family, faith, open-source-related— they each have their own color. That way, when I look at the agenda, I see whether a color is dominating, or it draws my attention. If I see colors that I know are work, I will see if those need rescheduling into the next day first.

17:00 Simplifying meaningful distinctions

Sacha: All right. And it looks like the rest of your agenda is fairly light in terms of showing those meaningful distinctions. So I guess you're just using the filtering of the different agendas and other blocks in your outline to do that kind of filtering of things based on the distinctions you've already made.

John: Yeah. I do still have lots of distinctions, but I have now narrowed it down. I used to have more, and then when I realized this concept, I started getting rid of as many of them as I could possibly get rid of. Otherwise it's just too—if you have to sit down and spend hours combing your data, it's just never going to happen. It's going to end up piling up on you and you'll never get to it. So this has to be a manageable amount of distinction, and every single one of those distinctions has to have precious value in helping me manage my focus.

18:01 Capturing a task

Sacha: Is it possible for you to walk us through an example of when you're capturing something and any structure you have to support making those distinctions?

John: Usually I'd capture everything into drafts. So if I want to create an item, I use org-capture. Actually, I capture it in two ways, so I'll show you both of them.

John: For capturing a task—

Karthik: Sorry, John, before that, Sacha, do you see the window having shifted again?

Sacha: It's doing the thing. I don't like seeing the thing.

John: It's not moving at all over here. So this has to be something wrong happening with the Zoom client.

Sacha: I don't know.

John: We're just going to have to keep resharing it at intervals. Because nothing is moving here.

Sacha: What if we don't make it full screen and we just make it slightly... Are you sharing the window or are you sharing the screen?

John: I'm sharing the window.

Sacha: Okay. You might consider sharing the whole screen if that's not too weird.

John: I prefer not to, only because lots of notifications pop up.

Sacha: Oh, yes. Okay, that makes sense too.

John: And then we would have to blur those out as well.

Sacha: Okay, then. All right.

John: What I can try to do is share the window as a full-screen window.

Sacha: Oh yeah, okay, well, we can work with that. Probably in post we can just—oh yeah, oh look at that, it's zooming in.

Karthik: Okay. This is perfect.

Sacha: We were talking about how...

Sacha: Let's say you're creating a new task. Do you just type in the text and all that stuff by hand? Or do you have something to help you make those distinctions?

John: What I do is hit M-m, because that wasn't being used for anything else, and that pops up a capture template for what I want to add. So let's add a TODO. I'm going to say "send an email to Sacha."

John: I try not to do any of that organization of the task at capture time. The idea with capture is that it gets onto paper as quickly as humanly possible. So I just hit C-c C-c, and it writes it out.

John: What will happen, because this is now in my drafts, is that it will appear at the top of my items needing review, and it will be in this very bright fuchsia-color background, which is extremely loud and always says to me, "You have items in your drafts that need reviewing."

John: So I go to the item—here I'm in my drafts.org file, which has an inbox and a collection of drafts. (That's the other thing I'm going to tell you about.) Now I look at, "Oh, send..." I don't like using filler words. I actually have a report that finds entries that have filler words. So I always get rid of "a" and "the," stuff like that. So: "Send email to Sacha."

21:02 Task metadata is mostly automatic

John: It comes with a lot of metadata. All of my tasks get a lot of metadata to start out. They get a notion of when I need to next review them. They always get a unique identifier— everything has a unique identifier, every entry, every file. They get the created timestamp, the GPS location of where I was when I created the task. The task itself is hashed so that I can know in the future when it changes, for a reason I will also explain shortly. The modified date is the last time the hash was updated, and that way I know...

Sacha: I'm curious, what do you use GPS for?

John: It's just information. Why not collect it? Any information I can collect that requires zero energy from me, I collect.

Sacha: Okay, fair, fair. All right. So you're saying hash. Okay, you got a hash.

21:55 Task hash detects modifications

John: So I have a hash of the content, which includes all the property values other than the hash, of course, and the title and the body and all that kind of stuff. It just lets me know when the item has changed. I have a procedure in my Git pre-commit hook which will ensure that the hash is correct, and the hash updates whenever the file is saved. This is all being done by a module I wrote called org-hash, and org-hash will do this all for you.

22:24 Categorizing tasks

John: So now what I'll do is—this doesn't really need much categorization. I will just put it under "friends," so I just file it under friends. I didn't give it a scheduled date, so that'll appear in my review list rather than any daily agenda. This one is a reminder to me to download an AI model once the quantizations are available for my machine, so I'll just put that into the AI category.

22:56 Daily reports should be short; reschedule or unschedule aggressively

John: Now my inbox is empty and I can go back to my daily report. This daily report, by the way, is too long. In general, daily reports don't work unless they're less than ten items long. I haven't done it yet today, but I try to aggressively reschedule or unschedule things that don't fit within ten items in a day, because I just will never do more than ten items in a day. Like, I talked with my wife about this item, so I'm just going to move that to the next day so I can revisit it. These work items are going to have to go to Monday now. I'll just get them out. I reschedule or unschedule pretty aggressively.

Sacha: Okay, so what I'm hearing is: you capture it very quickly, every so often you look over the bright fuchsia items in your review inbox, and say, "Okay, let me refile that to the categories"— the files, basically, or actually the places in your outline where they make sense. Then you have this list shown to you properly categorized now, but then you reschedule things until things look more manageable.

John: Yeah, the ideal scenario is that on a given day, Org-mode is showing me ten or fewer items, and those ten items are the things I should be thinking about and doing on that day. That is not the case right now, which means I need to curate this. But that is the objective function for this entire system. If the system can do that, it is succeeding. So I just work as hard as I can to get the system to approximate that behavior.

Sacha: Last time we talked, in 2024, you waxed nostalgic about LlamaGraphics Life Balance and some kind of automatic prioritization. You also briefly mentioned that you use AI sometimes to do sorting and reviewing. Is your workflow for prioritization still manual, or have you found something that works to help you?

John: I did start writing an org-balance thing— you and I talked about it a while back— I have not continued that. I don't try to do automated balancing. I just look at the daily list and pick and choose. That generally ends up being what happens. As far as the task management in an AI-friendly way, we'll have to come back to that because that's another thing I want to show you. I don't think, Karthik, that 30 minutes is going to be anywhere near enough to even just show you the outline of how it is a system.

Sacha: Yeah. That's why we have ongoing conversations.

John: Yeah, this will just be the 10,000-foot overview for today.

25:41 Note from Karthik: John is an old-school Org user

Karthik: If I may jump in, I'm thinking about this from the perspective of someone who knows what Org-mode is and maybe has used it once or twice and is now watching this on a video hosting platform and is going, "What? What's happening here?" So can we zoom out a bit? Maybe I should start by saying that John is an old-school Org user. I mean, he's also new-school as we'll see when we get to the AI stuff. But John is a veteran Org user who's been using it for 20-plus years, if I'm not wrong. There are functions in Emacs Org-mode that are named after John, or at least mention John in their docstring as the reason for their existence. This is what you're looking at, and what you were probably confused by, dear viewer, is the result of 20 years of using Org and organizing your life with Org and then optimizing and improving the workflow incrementally. This is kind of where you end up. Okay, maybe that should go in the intro, but now it's fine.

27:04 Continuing with the lifecycle: capture, file, schedule, review

Karthik: Maybe we can continue with the capture example that you were showing—the typical lifecycle of a piece of information, right? It starts as a capture and then shows up in the agenda. Well, it shows up in the agenda very brightly saying "pay attention to me," and then eventually gets filed somewhere. Let's continue from there. What happens next? What happens to the email that you haven't written to Sacha?

John: Well, either I schedule the task at that time and then it's going to appear in one of these daily agendas, or— as I'm looking at my agenda here, you'll see I have my items for today all grouped out by org-super-agenda.

27:48 Habits

John: Then I have habits, which is a different type of task where I'm trying to track consistency rather than completion. I use habits a lot, especially because I really love the book Atomic Habits. It makes some really good arguments about the importance of behaviors and processes to getting things really done.

28:09 org-review and items needing review; randomization

John: Then at the bottom of every agenda view is this section, "items needing review." I have close to a thousand items currently needing review. I can't review them— that's too many to review. Even if I just looked at the work ones, it would still be too many to review. So what I choose to do instead is that every time I refresh my agenda view, it picks 38 unreviewed or unscheduled items at random and puts them here in this list. What I do is I just sort of scan it to say, "Is there anything in this list that really I should be doing? Should I be scheduling something?" I don't even try to read the whole list because that is too much. I just cherry-pick. I say, "Oh, is there anything? Oh, look at this— 'set up active voice chat with OpenClaw.' Well, that's going to be priority C, that's not very important." Or this one, "front braking on my bike is not very responsive." You know what? I don't really care about that right now, so I'm going to tell it to show it to me for review later in the summer. I have a bunch of key bindings behind the key r, which allow me to change when it will be reviewed by.

Karthik: Okay, so to clarify, this idea of a review is different from anything that Org provides you out of the box, right? This is not scheduling the task to be completed at a certain time. This is not a timestamp in the sense of an event in a calendar. This is not a deadline. This is like a different concept that means show this to me after this time. Is that correct?

29:49 org-review task properties

John: Yes. If we look at the task itself, we will see in the properties for that task it has these three properties: LAST​_​REVIEW, NEXT​_​REVIEW, and REVIEWS. These are added by the org-review package, which is an add-on to Org-mode that's not part of the stock distribution. LAST_REVIEW is the last time it was reviewed, of course. NEXT_REVIEW is the next time I want to see it in the reports that gather tasks to be reviewed. That's the only time that date ever comes into play. If that date NEXT_REVIEW is in the future, it won't show up in those 38 items that are randomly selected underneath my tasks. So if I've reviewed every task and they're all in the future, then that list at the bottom of my to-do list would be empty. It has been empty sometimes when I'm on vacation and I have the time to actually review tasks. REVIEWS is something I added to keep track of how many times I have pushed that into the future, because then I can create an agenda report for the redheaded stepchildren in my Org-mode database— who are the people that are just keep getting pushed and pushed and pushed and never getting any attention?

Karthik: Okay, so this is like a whole subsystem that you added to Org to handle the kinds of tasks that are maybe important but not urgent?

John: Right. Because there has to be a midway between "these are the focus tasks for today" and "these are all the guys that aren't scheduled." There has to be something in between those two, because the gap is too large.

Sacha: All right, so instead of just relying on scheduling, you use reviews to give you that extra level of "I want this to come back on my radar every so often." You will actually have a randomized subset of these things to come back on your radar every so often, but you're not necessarily scheduling it for that day, so that your scheduled tasks still focus on your priorities. Right.

31:48 It's all just plain text

John: Now, at the end of the day, Org-mode files are just text files. That's one of the beauties of the whole system: they're really nothing special. Because it's Org-roam on top of Org-mode, I have many files. I have hundreds and hundreds of Org-mode files. Many of them contain tasks, many of them do not. I use some advice from the internet on how to optimize the collection of tasks for the agenda so that it only opens the files that have tasks in them. That way it stays nice and responsive, even though the number of files is constantly growing. The reason I use separate Org-mode files is, yes, I do separate by topic sometimes— I have a file for work and a file for personal— but I also like to have an individual file for every meeting. At work, if I have a one-on-one meeting, a team meeting, a project meeting, an all-hands meeting, I will create a file for that meeting. I will put into it who the attendees are and what was the agenda. I will have an AI note-taker (usually Gemini or Fireflies or something like that) on during that meeting, so that I can include the summary, the action items, and the transcript from the AI note-taker inside that file when the meeting is done. I also have a notes section where I collect all of the Org-mode tasks and notes. I don't use the drafts mechanism to capture in those instances; I capture them directly into the file.

33:18 Capturing to the current point with M-0

John: One of the nice things about Org-mode is that when I hit M-m to select the capture template, that's going to go into my drafts file. But if I hit M-0 M-m, then it's going to capture it where I currently am. So I could say M-0 M-m a,

John: and then I could say "send email to Sacha" again— you're going to get lots of emails, Sacha—

John: and as you can see, it's right here in the file where I was a moment ago. That's what I use to capture stuff into the one-on-one files. So I use M-m if I'm using the Org-mode capture, which is for individual items that either are in my current location or in the drafts.

33:59 A different set of Org Roam capture templates

John: Then I use C-c M-m for a different set of capture templates, which are for Org-roam files. If I do C-c M-m, then I can go to my work templates, my Bahá'í templates. I could capture a note, which is an independent empty file. I could capture a blog for one of my two blogs.

34:18 Capturing by name

John: So let's do work. I'll say "work," I'll say "O" for one-on-ones,

John: I'll say "D" for names that begin with D,

John: and I'll say "W" and it will be my manager. What that will do is now it pops me into an Org-roam file where all the metadata for this file has been set up: the right category, the right file tags, creation date, everything.

34:38 An after-save hook automatically renames the files

John: I like to add the meeting time to the date. When I save the file, then there is an after-save hook that will automatically rename the file so it has the correct date and time in the filename.

34:54 org-ql in the template provides a meeting agenda

John: Then you can see that it has pre-populated an empty org-ql column view,

John: which I then hit C-c C-c on. So now, if the person I'm meeting with has not provided me with an agenda, I have an automatically constructed agenda for that person based on what I know I have to do for them in my Org-mode data. When I was a manager for several employees and would use Fireflies to capture all the action items from all of our meetings, this was how I followed up on all those action items with all the people. I had one-on-ones with every direct every week, and I would auto-populate agendas for those meetings from Org-mode. Then I would just go through the agenda with them and say, "What's the status? What's the status?" and just keep that moving forward. That ended up being a really nice system for making sure that all the action items we committed to were being completed.

35:49 The "Review by" argument for the column view block filters the tasks

John: You can see here on this org-ql column view I have this :REVIEW_BY tag. That says, "If the NEXT_REVIEW date for the item is beyond this date, don't put it here. It doesn't belong in this agenda." That way, if a person says, "Oh, I'm working on this, but it's going to take me two months," I'll say, "Well, I'm going to check back with you in two months." Then I'll just set the NEXT_REVIEW for that item to be two months into the future.

Sacha: And then for the ones that are there that you're reviewing, as you're sitting in the meeting with them, you're opening up the other tasks in another window and updating your status?

John: Usually, yeah, I'll do this.

John: I'll open it up and see whether there's any supporting information. There may be links to files, links to URLs, a description.

36:36 Copying from Slack to paste into tasks

John: I like to copy and paste from Slack into tasks. In fact, I have a whole pipeline for that. I use Slack through Firefox because Firefox has a "Copy as Org-mode" plugin. So what I do is I drag and drop over the entire conversation that I want to make a task out of. I hit Home on my keyboard, which uses Keyboard Maestro on my Mac to copy that as Org-mode, switch to the Emacs application, capture a task, insert the Org-mode Slack text that it just captured, and then run an Emacs Lisp function called org-fixup-slack, which will rewrite all of the links and all of the markup to match what I want in my Org-mode files. Then I ask Claude to review that content and synthesize a title for that to-do item for me. Then I will tag it with the person I need to work on this with— or I'll switch it from TODO to TASK, which means it's delegated to them, and then I'll tag it with their name, which means they're the ones working on it. I have to check in with them on our next one-on-one to see whether this was completed.

Sacha: All right, so that's how you get external information such as Slack conversations into your notes, formatted the way that you like to format them, and into your whole agenda review meeting process.

38:13 Using gptel and large language models to generate titles and identify tasks

John: Right. And Karthik is the author of the wonderful gptel Emacs interface— that's the interface whose API I use to do the title synthesizing. I do a lot of title synthesizing. I do not write Org-mode titles. I just paste in lots of information and then ask Claude to create the title for me, because I've taught it what kind of titles I like. In fact, I could do that right now. I could go into notes, I could create a TODO here. That didn't work.

John: I could create a TODO— I'm using yasnippet to create the TODO. I have to fix my org-review today, so one second here while I make a task to fix that.

Sacha: Of course.

John: And that will be scheduled for today.

Sacha: That sounds like a good opportunity to copy the error message, paste it in, and demonstrate how Claude will do the thing for us.

John: Yeah, well, it might. I could do it this way.

John: I type C-x c t — C-x c is my prefix for all things AI, and T is "make an Org-mode title." Actually, it's not using Claude, it's using my local AI. This is going to take a little bit longer. So while it does that, I'll tell you about other things. It can do it asynchronously, so I can come back here and tell you about this. So I'm here. What was I saying? What was I going to do in this file? I think I was just going to show you the creation of a TODO here.

Sacha: Yeah, we were talking about copying the information from somewhere else. You've got this big paste, and then you're getting the AI to give you a title that summarizes the action item.

40:03 after-save-hook adds a TODO file tag; the TODO file tag adds it to the list of org-agenda files

John: Since I've created a TODO, and since I saved the file (which is what caused it to then create the hash), you'll see that it has added "TODO" to the file tags. This is how the system knows to add it to the set of org-agenda files, so that the org-agenda will now get the TODOs from this file as well.

Sacha: Okay, adding to the agenda. Gotcha. All right. Now, you mentioned the hash a few times. Go ahead.

40:33 Reviewing the task

Karthik: If I may jump in briefly, I feel like I'm trying to catch up to an F1 car on a bike. I want to go back to the flow of that one task about writing an email to Sacha very briefly. You said you filed it and then it shows up in the list of things to review, right? What happens from there is that either you schedule it, or you just do it at some point, or you push it forward into the future. Is that right?

John: Say that one more time?

Karthik: The task about writing an email to Sacha that you captured and then moved into the friends category— I want to know how the task actually gets done. How are you reminded of it two weeks from now, let's say?

John: Well, it'll have to show up down here in the tasks to be reviewed.

Karthik: Uh-huh.

John: But randomly.

Sacha: Let's pretend you're scheduling it for today, because it's very important you send me an email today. So if you want to refile it to find it again, we can schedule that and you can send it in. Because I think Karthik just really wants to see the task marked done.

Karthik: No, you don't even have to write an email to Sacha—

Sacha: Oh, you can.

Karthik: I mean, you can if you really want to.

42:04 Karthik: "Things I capture in Org never get done."

Karthik: So okay, I'll tell you the reason why I keep focusing on this. It's because everyone knows how to capture in Org, right? And then everyone also knows how to get a list of all TODOs. But things I capture in Org never get done, right? So I want to know what the mechanism is to force your hand into actually sitting down and writing this email. Of course, if it's urgent and there's a deadline, it gets done, right? But it's the things like this where, oh, it would be nice to write this email and then follow up on this.

Sacha: I think the problem, as you said earlier, the problem is the human.

42:40 Grazing through tasks

John: Yeah, the truth is it may never happen, Karthik, but it will be here as an open task. As I have time in my life, I do graze through my tasks. I cut it in different ways to try to refresh myself on what hasn't been done, and there will come a day when I will see this task again.

Sacha: Okay, yeah. Anything that's got a time on it goes into the priority queue, and anything that would be nice to have goes into— someday it will show up in John's lottery of random tasks and then he'll be like, "You know, I'd rather do that task than all the other tasks. Let's do that one instead." Just a quick question, because we're coming up...

John: Oh, we haven't even really scratched the surface.

Sacha: I know.

John: There are major, major things underneath this that I haven't even mentioned yet.

Sacha: I can keep going if you can keep going. So up to you.

43:36 This is an advanced Org workflow

Karthik: Also, I know more than I'm letting on about John's Org workflow, right? I'm just trying to ease the viewer into it gently because— what's the goal here? I don't think that this presentation is for people newly introduced to Org-mode.

John: I just don't think you can. I don't think they want my system. This is too complex. What I'm hoping is that people who already use Org-mode will cherry-pick out ideas that could advance their system a tiny bit. But nobody should do everything that I do, because I can barely survive it. It's too much information.

Karthik: There's no way that I was expecting this to be a tutorial. Not at all. It's just that I want the viewer to come away from this knowing what's possible and understanding what you're actually doing. Right.

Sacha: This is definitely aspirational. This is the thing that helps people think, "Oh, you know what? That's possible. Now I can go look up org-review or think about writing validation functions for my Org-mode, before-save hooks or actually after-save, that rename my files." So they can look through it. They're not going to be able to just pull the whole thing from your repository and plop it into their system right off the bat, but they can look at it for ideas, seeing how it all comes together.

45:11 Drafts: write down the text and then decide what to do with it

John: I mentioned that I was going to show in the drafts how I have an inbox

John: and a draft section. I've just recently added a new thing to my workflow, which is, instead of collecting drafts here... So what is a draft? A lot of times when I'm going to capture,

John: I hit M-m and I pick from the options of what I want to capture. That creates a template for that type of item. But sometimes that's too much thinking up front. I don't want to have to distinguish between a TODO or a note or a link or anything else. What I want is to just get the text out of my mind absolutely as fast as possible. For this purpose, I wrote org-drafts. I named it after a Mac application that I've been using for years that does exactly the same thing. Drafts lets you write first, act on the information later. In Drafts, the Mac app, you can write some text and then decide you want to send it as an email, send it as a message, send it as a WhatsApp—you know, but you shouldn't have to be thinking about the mechanism of action when you first just want to think about the creative act. I have changed it so that, instead of just M-m,

John: if I do M-S-m, it creates a draft. It used to create the draft using the org-capture interface, and then it would go into that drafts subheading in my drafts.org file. But now what it does is it goes into my lab notebook.

46:47 My lab notebook collects notes and ideas throughout the day

John: So the lab notebook is where I want to collect notes and ideas throughout the day. I don't know that I want it to be in the lab notebook— the point is, I don't want to think about it. So when I do M-S-m, then what it does is it creates a draft instantly at the bottom of my lab notebook, and it puts me in the body of that draft to write it. So I could then say, "Send an email to Sacha." That's all I have to do. I don't have to hit C-c C-c. I don't even have to save the file. I could just go straight on to what I was doing. But the idea with org-drafts is that, once you have written a draft, now or at any time in the future, you're going to want to act on that draft in some way.

John: So if I hit C-c C-c, it pops up a little submenu of things I can do with this draft.

John: If I hit t, it'll take the first line of the body of the draft and turn it into a TODO with that line as the title of the TODO.

John: If I hit C-c C-c c, it will copy the body of the draft onto my clipboard and then change the keyword of the draft to SCRAP. SCRAP is just a keyword that I use to identify drafts that I don't need to act on anymore but I like to keep the information. Maybe I want the information in the future.

John: Another thing I can do with it: I could do C-S-c, and what that will do—you don't see it because it didn't show up there— but it starts up a webpage into Claude.ai and inserts the body of the draft as the text to submit for the prompt to that webpage. This is extensible. You can add new actions to this. I can draft an email with this. I don't have it set up to send Apple Messages, but I could. I could set up that interaction as well. This is now a preferable way for me to collect ideas and thoughts and notes throughout the day. So when I'm using Claude Code, which is what I'm generally using, and I write a really long prompt and I think, "I may want to use that prompt again in the future," I will copy and paste it and then make it a draft, and not do anything with it. Actually, I just turn it into SCRAP right away with another keybinding, but I want to retain it within my lab notebook so that I can use other forms of search, which I'm going to talk about in a moment, to try and recover that information and find it later.

49:17 org-jw: normalizing structured data

John: I said that Org-mode is text, and that is a strength of Org-mode. It is also a weakness of Org-mode, because really Org-mode is a database— but it is a super-unstructured database. I have spent more than a year now layering a system on top of Org-mode I call org-jw, simply because it is so specific to my workflow that I didn't think it would ever be of general use. What org-jw is, is a separate Haskell application that parses Org-mode files into an internal representation in memory of those files that's entirely complete. When I say "entirely complete," I mean that if I take that in-memory representation and write it back out as an Org-mode file, it is byte-for-byte identical to the Org-mode file that went in. It checks this property by doing a round trip. If the file fails the round trip, it raises an error saying your data is not conformant. I make this a pre-commit hook before anything can be committed to Git as a change to my Org-mode files, to ensure that if it's in Git, it is normalized. This fully normalized data now is accessible in new ways. I wrote a whole linting process that checks hundreds of different properties of my Org-mode data to make sure that those properties are always maintained. For example, if there is a URL property in an entry, it must have a "link" tag, and vice versa. Those two things have to go together, because the link tag is there to be a reminder to me that there is a URL and it would be meaningful to use C-c C-o on that entry. Likewise, I don't want it to have a link tag but not have a URL. The two always have to come together. There are a whole bunch of linting rules that I have, but they're all specific to me and how I like to use Org-mode.

51:17 Copying structured Org data into a PostgreSQL database

John: Another thing org-jw does, now that it has this internal memory representation, is it can write all of that data out to a highly relational database. So it's, I think, a third-normal-form or fourth-normal-form Postgres database that collects all of the information. When I say third normal form, I mean that tags are in their own table, categories are in their own table—every little piece of information is in its own table. Then there are correlating tables. So each entry is identified by its UUID, and then the tag knows what entry it goes with by basically referencing that UUID. All the data is interlinked like this. In addition to storing the data in this database—and this is the text of every property, the text of every note, the text of all the body paragraphs, everything is in there—because all of that data is now so nicely structured within the database, Postgres has the ability to do vector search. Anyone that's been playing in the AI space knows about vector search. When I use org-jw to reflect all entries that have recently changed back into the Postgres database, I also use an AI model to calculate a vector embedding for every piece of text that's related to every entry. These get stored as vectors in Postgres, so that later I can ask the database, "Show me entries that are related to a leak that I'm searching for in my pool." It will search for that semantically within the database, and it will find me everything that is in the area of pools and leaks and all of that kind of thing. This is very effective. I can do it on the command line with org-db-search—that’s the name of the command that I run to do this.

53:12 OpenClaw enables conversations with the data

John: But I also taught OpenClaw how to use this tool. So OpenClaw is an AI agent that will do work on your behalf. I have it linked up to a local LLM that I run, and I get to talk to it over Discord. It's really locked down— I have it all bound within its own Linux microVM so that it can't really do anything but the few capabilities I've given it. But what it means is that, when I'm on the airplane, I can use my phone and my WhatsApp or my Discord app, and I can say, "What tasks do I have coming up in the next week that involve calling somebody?" Then it can do both a full-text search, a structural search for tasks, and also a vector embedding search to find similarity. So I could ask OpenClaw, "Do I have anything coming up having to do with Christmas ornaments?" and it will find for me the items that deal with Christmas ornaments. What this has all done, by starting with Org-mode and then creating basically what I call "strict Org-mode" or "structured Org-mode," from that creating a database, from that creating these vector embeddings, and then from that tying it into an AI agent, I now have the ability to dialogue with my data. I can ask my whole entire Org-mode sea of data questions like, "What problems at work have I not been paying much attention to lately?" and it can give me an answer. Then I can query that answer and refine it further. I can say, "Well, do any of those have to do with this project?" or, "Do they seem like they're very high priority?" I can keep going until I get to a more refined set of items that represent a focus for the day, as an alternative to using the scheduled dates and the org-agenda reports. But I also have an org-agenda report which does a vector query. They all tie together, so I can do it from whatever direction. If I say, here, "org-semantic-search," and then say "go out for a coffee with Karthik," what it will do is run the org-db-search command-line tool and then feed the data into an org-agenda query.

Sacha: So I'm hearing: you've got your Org plain-text data, you make sure that it's all formatted nicely using your normalization functions, you take that and put it into a structured PostgreSQL database, which then allows you to do a full-text search as well as vector search. Then you take that and you hook an AI into it through something like OpenClaw, so then you can have conversations. Even when you're away from your computer, you can query it for stuff and do something with the results. Even just the semantic search is something I'm very interested in because it's hard to find things if you need exact word match, so this is great for being able to find stuff that's related to something without having to worry about making sure you've got the right words in it.

John: Right.

Karthik: This is like five levels of crazy, each building on another.

John: Yeah, it's all about making this data work for me. I've spent all this time collecting it—how can I make this data work for me? I don't know why the CLI search is not working. It might be some problem with the local model. So many changes. So many. Yeah, it's the demo phenomenon. Also, so many things change in my environment so fast that, unless I use things constantly, they easily break.

56:49 Avoid drift by using only one TODO system

Sacha: Which actually is an interesting thing that touches on the conversation that Karthik and I were having before you joined. How do you keep the ideal of your tasks or whatever synchronized with the reality of your current focus, or the things that have broken or changed?

Karthik: Yeah, it's the drift. I call it the drift problem, where the state of your life—well, the portion of your life that you want to capture in this case in Org—has drifted from what's actually happening. Then when you look at your agenda, you go, "No, this is not relevant to me anymore. The things that are bothering me right now are not here." So it's like the Venn diagrams—I mean, the two blobs—the overlap is getting smaller and smaller. So is that a problem you have, and if you do, how do you deal with it?

John: I deal with it by not using any other systems but Org-mode. So you have to always be in Org-mode, seeing that data somehow. You have to just be interacting with it to combat that drift constantly. You can't have even two to-do lists. For me, even just one other to-do list makes the drift unmanageable. So if somebody puts something for me on another to-do list, I'll make an Org-mode task and I'll put a link to that to-do list. It has to be in Org-mode.

Sacha: Do you sometimes find yourself— go ahead.

Karthik: What about the to-do list in your mind?

John: I don't keep a to-do list in my mind.

Karthik: You don't have a to-do list in your mind.

Sacha: I was just saying, as we saw earlier, if you do come across—if there's a thought and it's not in your current review list and it's not in your current agenda, your semantic search and your org-ql will help you find that thing relatively quickly, I think.

John: Yeah, if it's in the Org-mode file anywhere, a combination of either ripgrep or Postgres full-text search or semantic search, there will be a way to find it. Then if it's not in there, I just use the capture interface to put it in there.

58:59 Capturing with Drafts on the Mac or Apple Watch

John: Oh, by the way, I also should mention how I capture. I've been showing you Org-mode commands to capture, but that's not actually how I typically capture tasks. I use the Drafts app on macOS, as I mentioned, and I have it set up so that in the Drafts app, if I hit C-c, it will write the item that I captured in Drafts to a file that Org-mode will turn into a task the next time I run any agenda command. So I have something that's the after-agenda, the before-agenda setup hook. Let me do that. I'll go over to my Mac and I'll say, "Send an email to Sacha." I'll then submit it. It goes to iCloud Drive, gets synced to all my machines.

John: Now I'll regenerate my Org-mode agenda. And now here it is—this fuchsia guy just came in from the Mac Drafts app. The Drafts app on the Mac runs on my phone and it runs on my watch. So what I do to create tasks is I tell my watch— I just talk to Siri and I say, "Remind me to do such-and-such." Then the Drafts app knows to automatically suck in anything that's on my Reminders list, and that ends up becoming something that's auto-sucked into Org-mode. This way I use voice to capture things as they happen wherever I am. I don't have to have my computer. I don't even have to have my phone. I just need my watch at the very least, and I'm capturing tasks by voice like this, dozens of them a day. This is probably the most frequent way that I do it. Oh, and also, I taught OpenClaw how to add stuff to Drafts. So I can also ask OpenClaw via Discord, "Hey, remind me to do such-and-such." But why do that? I just did it as an alternate way. I prefer to do it with my watch.

Sacha: Yeah, just because you can.

1:01:01 A foot pedal makes speech-to-text even more convenient; whisperflow, handy

Sacha: As I was mentioning, voice computing—just speech-to-text— is very interesting because it allows you to capture your thoughts so much faster than typing. So I was wondering if you're using any of that in your drafts, not just for quick tasks that you're capturing from your phone, but when you're at your computer, are you using that at all yet?

John: Yes. In fact, I am using it so much that I bought a foot pedal for myself.

Sacha: Yeah?

John: Yeah. I use two different apps. I use one that's commercial called WhisperFlow that sends your voice out to the internet and uses their AI models. First they transcribe it, and then they process it— they remove all the uhs and the ums and they rewrite it into correct grammar and all that kind of stuff. That's extremely fast, so usually when I'm talking to Claude and prompting it, I'm prompting it by voice using my foot pedal. That's the right pedal. The left pedal uses a free open-source app called Handy. Handy uses a local transcription model, which I use Whisper Transcribe for, because it's super fast and super accurate. Then I use Qwen 3.5 9-billion-parameter as my local LLM model to post-process the transcription, so that it does the same things that WhisperFlow does. It can accomplish everything WhisperFlow does; it just takes about ten times as long to do it. Sometimes I don't like that delay in the flow. But it's also entirely open source and entirely local, so I know that whatever I'm transcribing, none of that data is going out to any third-party services.

Sacha: Fantastic. Okay, so that gets you— when you're brain-dumping a whole bunch of things into a prompt for an AI or into your notes before a meeting or whatever, you can just blurt a lot of information and the AI will clean it up nicely and make it more presentable.

John: Let's do this. "Send an email to Sacha." Now, it just finished transcribing. Transcribing only takes like half a second, but now it's processing. It may take longer the first time because that 9-billion-parameter model may not be currently loaded—I had to reboot my machine recently.

Karthik: Sacha, you're going to get so many emails.

Sacha: I don't know, it's fine. It's fine. I get emails sometimes. Go ahead.

John: Oh, there we go. So it said, "Send an email to Sacha." It nicely added a period at the end of it.

Sacha: Yeah.

John: Let's see. Now that it's warmed up, let's do a longer one. "This email should say something about Org-mode and it should be related to the conversation that we all had on our Zoom call together." You could hear that I had— I don't know if you heard me, but I had some uhs and ums in that.

John: But this is what it came out with. The only thing it didn't know how to do was put a hyphen between "Org" and "mode." I have complete control with Handy over the post-processing prompt. In the post-processing prompt, I can give it an Emacs section and tell it about vocabulary that's special to Emacs that I want it to be aware of. I've done that for all of my work topics, but I haven't done it for the Emacs topics.

Sacha: I have something similar where I do the post-processing of the speech-recognition output in Emacs, so I can just run a list of functions on it, including fixing common errors and processing speech commands. So I'm gradually playing around with that too.

John: It's invaluable. The other nice thing about voice transcription is that you end up saying more than you type, because I think we just naturally economize— typing takes more energy. When I talk, I'm just a blabbermouth and I end up giving all this information that ends up being better for AI. In fact, they've shown that if you just add 40 more periods at the end of your sentence, that improves the quality of your response, because all of those additional tokens cause attention to be recomputed for the existing tokens many, many more times, and that computation helps it find its way through the feed-forward networks more accurately. So more text is actually better, especially when you're only talking about maybe 20% longer due to voice transcription. So I prefer to talk to AIs through voice. What I do is I like to create—let's see here— I like to create the body of the TODO using voice transcription, and then after that I like to create the title using AI as well. Now that it's warmed up, it should not take quite so long.

John: There we go. We will just say to Qwen— that was Qwen 9B giving me the transcription— now we're going to use Qwen 27B to give me the title. It may not be warmed up as well. I try to keep four different models always loaded so that they'll be quick to respond, but as I said, I had to reboot the machine recently.

Sacha: All right. So you've got your outline for focus and your home, they have the blocks in it, you can use that to drill down into whatever subset of your tasks. You also have your agenda with the reviews. You can go into any of those tasks, use AI to fill out the text based on your speech recognition, or you can send it to Claude or other AI for executing the task, for all that stuff.

1:06:39 Looking to the future

Sacha: If you're looking three to six months out, your workflow is pretty polished, but where do you want to take it? What are your future needs that you'd like to work towards?

John: I just need to be able to get these big old long lists shorter. That's all I want to say.

Sacha: Yeah, that is a getting-things-done thing, not a tooling thing, right?

John:

Yeah. Atomic Habits, I think, helped me more

than anything else in the way that I break up tasks.

1:07:07 John is running local models on a Mac Studio

John: I'll give you another AI example here. For some reason, Qwen is not working. Let me check my OMLX— I use OMLX these days for running.

Karthik: So you're running all these local models on a Mac Studio?

John: Yes.

Karthik: Okay.

John: Oh, it looks like OMLX might not be running. No, I have it.

Karthik: Okay. In the meantime, I had a question about the whole database mirror of your corpus.

John: Okay, sorry, one sec. The reason it wasn't working is because I'm also working on another AI-powered app for doing stock analysis, and it was taking over the port. So what was your question?

1:08:12 Using AI to facilitate getting data into PostgreSQL; structural limitations?

Karthik: Yeah, so the question was: you have a mirror of your Org corpus in Postgres, right? I was thinking, one of the reasons that people like Org-mode is because it's easier to work with as text, but also because it's flexible. So you can set up whatever system you want corresponding to whatever schema in the database. You can also change it easily because it's just text, right? But your Org subset specification, by your own admission, is rigid, right? You've settled on it for now, and that's why you can have a database that's like this with a one-to-one connection. What happens if you change something? Like if you change what a category means or if you add more things, you have to then update all the tables in the database and update the schema. You have to do a migration of the database.

John: Yeah, but I just have AI do that for me. I didn't create a schema. I didn't even create the code that did the Postgres migration. That was all written for me.

Karthik: I suspected that, yeah, that's probably what you do. You don't worry about it. That is neat, the idea that you can have all the flexibility of Org-mode—flexibility to change things, change the system as your needs change—and then also have the database do all the things it does, like very fast search, semantic search. You get all of that for free, if you have someone who can go and change the database when you change your Org system, if you have someone who can do that for you.

Sacha: It actually prompts me to think of this question I had about stuffing the Org entries into the database. Let's say, for example, you have an Org tree and you have sub-entries within it that you also want to be able to work with on a more granular basis. If you have subheadings, how do you like to put it in your database? Do you have a copy of everything, and then each sub-entry has its own entry as well, and then each subheading under that has its own row in the database? Or are you only working with the most granular ones?

John: I don't even know, actually. how the AI decided to organize it.

Sacha: Okay, yeah. So basically, when you do a search, for example, can you find something where the keywords are in multiple subtrees of a larger entry?

John: I could do a join and find that information, because every entry knows what its parent entry is, and it could find out what the keywords for those parents and for any siblings would be as well.

Sacha: Interesting.

1:11:04 Habits are better than goals

John: All the data is there. I was going to mention, by the way, that I was talking about Atomic Habits and how much that has affected the way I break tasks down. I try to get them to be smaller, and I also try to rely more on habits than on goals to accomplish things.

1:11:24 Breaking down tasks with a large language model

John: So another thing that I built up in Org-mode using gptel is— let me find an entry that's long enough for this to work. Okay, so here we have a relatively long entry. It's a note here, and it's about bridging non-switching ports on an OPNsense router. Let's say that this was something I actually had to do now.

John: I have this C-x c prefix that I use for talking to AI. One of the things that it can do is called a "task breakdown." So I do C-x c, and there are two of them: capital B and capital T. Capital B is designed to take something that is already a task and identify what the component tasks would be, probably, that need to be done and in what order to get this thing done.

1:12:13 Inferring tasks with a large language model

John: Capital T is "you've just got a sea of text— infer the tasks that are implied by that text." I wrote that one because sometimes when you use these voice transcriptions of meetings, all I have is the transcript, and I want to know, well, what were the action items? So I wrote "infer tasks" to get the action items. Let's infer the tasks out of this OPNsense router. So I will run that. I'm using now the Claude Sonnet model— I think I'm using the Claude Sonnet model. We're about to find out. Let me actually see which model that uses.

John: So that uses the "infer tasks" preset. The infer tasks—oh yeah, it uses the Sonnet model. I do not know—oh, maybe I have to block out the text. I mean, select the region. There we go. So what that did—you know, for some reason Claude was changed recently and it does not work for these types of tasks anymore.

John: "No actionable tasks identified in this text." Let's go somewhere else. Let's go to a work meeting. This is my directory that has all the meetings in it. Let's find one that has a transcript.

John: This one has a transcript. So we're just going to select the whole transcript, and the transcript got sent to Claude. We'll see what it comes up with.

Sacha: All right. So AI help for identifying the tasks and also asking you questions, I guess, to break down tasks.

John: It doesn't ask me questions.

John: So these are the seven tasks that it inferred from the body of the transcript. It even identified that two of them were tasks to be done by the person that I met with, and the other five are the ones to be done by me. They have descriptive text, possibly, showing the context that it used to determine that that text should be there.

John: It even has the time codes as a property, so I can go back to where in the transcript it got that task from. That ends up being extremely valuable, especially when I'm dealing with— like I said—a sea of information, and I want to pick from that sea which fish I intend to catch. I've been using AI with gptel and Org-mode more and more connectedly to try and help me manage—not just manage that sea of information, not just search it and categorize it, but also refine it, break things down into more manageable pieces, help me find which things I should work on today. All of that is coming together rather nicely to help combat the drift problem that Karthik was talking about.

Sacha: And it's so easy to work with because it's all text, and you can just give it that along with your prompts. Do you share your prompts anywhere?

1:15:35 johnw/prompt-deploy has the prompts

John: My prompts are all on GitHub. There's a project that I wrote called Prompt Deploy, and you'll find all of my prompts in there. Prompt Deploy is both a set of prompts, agents, skills, MCP tools, and models, and then a Python script that will deploy it to all of your agentic frameworks. It knows about Factories, Droid, OpenCode, Claude Code, Codex, Gemini—and it knows how to rewrite that information so that the prompt is usable in every one of these for every machine that you use all of these things on. When I do a Prompt Deploy, it writes out 896 different files to all of these different tools in all of their different locations. Because I only want to define the prompt once.

Sacha: I'm looking forward to having a good poke around. Now, interestingly, in our last conversation, I think one of the ideas was to then take the transcript of that conversation and see if a meeting summarizer could do something with it. I don't think we actually went through with that last time in 2024, but maybe this year it'll do a better job of pulling out the key topics. I will still probably edit the transcript manually, because transcripts are fun. Yeah. But okay—

1:17:02 Summarizing our conversation so far

Sacha: Today, the conversation was mainly about your kind of Org task lifecycle, including using AI to help you refine the tasks further. Karthik, do you have anything that you want to dig into a little bit more?

Karthik: I don't think we'll have time to discuss philosophy today—the philosophy of task management. But I do want to say, I think we covered how things go into the system and then how things surface, right? Things go into the system using manual captures, using voice or whatever, or they're created by LLMs. Then things come out of the system or are surfaced using the various agenda views, right? I hope that that's a somewhat complete picture of just the ins and outs—tasks go in and then they show up in various ways. There's a lot to take in. I knew some of this, but this is still too much. I've been using Org for nearly 20 years and I can't even wrap my head around it. It's easy to think of these as cool things that might be possible, but to actually see them being used— and usefully—there's a huge gap between the two. The fact that John actually uses this productively is pretty crazy to me.

Sacha: I think we can break it down into a couple of practices that people might be interested in experimenting with. Like, for example, that idea of using those kinds of focus or home dashboards—an Org file where everything is organized by your hierarchy of importance, and includes the dynamic blocks to list the actual tasks for that section, or the links that you can open with C-c C-o.

1:19:13 Karthik's completing-read version of C-c C-o

Sacha: Karthik, did you know that C-c C-o could open all the links, Because I did not.

Karthik: Yeah.

Sacha: So let's go.

Karthik: I knew that, and I also wrote— I didn't like the way Org does it, so I wrote a completing-read version of that.

Sacha: Oh, very cool.

Karthik: That's what I use, and I use it from the agenda. So if I do C-c C-o in the agenda, it shows me a completing-read interface with all the links in that entry. The reason I did this is because now I can do other things with the links. I can use Embark. I can export the links, just the links. You're not limited to just opening them.

1:19:56 Karthik's thoughts on the demo so far

Karthik: But anyway, it's just difficult for me to wrap my head around the fact that all of this comes together in a way where it shows you what you need to see when you need to see it. Yeah, it's like magic to me. I don't know how else to describe it. As proofs of concept, all of this makes sense— every individual feature. But the idea that it actually works—and then when you see it, you're not like, "Oh, I see what you're showing me, but that's not what I want to think about right now." The fact that that doesn't happen, or if it does happen, it's in a minimal way—it's pretty impressive.

Sacha: It's something that people will have to ease into as they try out different parts of this workflow. Things like using the org-capture, even just with the menu that you have, where it breaks it down into lots of levels—names starting from A to D, that sort of thing. Yeah, it's a lot of cool stuff, which we will try to write about and index, and maybe use screenshots for, because otherwise I think Karthik goes slightly crazy with the blurring.

Karthik: No, for the most part... The only challenging moments are when you were scrolling line by line, because that gets... But most of the time it was static, so it's easy to draw rectangles.

1:21:29 Categories are subject areas

Karthik: There's one other thing I wanted to ask you, which is how you break down... So Org has a few affordances. It has TODO keywords, categories, properties, and tags, right? I just wanted to know what meanings—you're free to assign whatever meanings you want to all of these, right? There are different ways to break this down. I just wanted to know, for the record, how do you think about each of these things?

John: For me, categories are subject areas. So if I want to see everything that I currently have in my TODOs related to AI— because those are usually fun tasks— then anything that is in the AI category, or under the AI category (one of the subcategories), I can just do a category report for AI and I will see all of those tasks. Sometimes when I have an evening and I just want to play, that's the report I'll do.

Karthik: But sorry, categories are mutually exclusive though, right? When you assign a category, it owns that task.

John: AI is a child of the Computer category, which is a child of the Personal category. So they're hierarchical.

Karthik: Oh, categories can have children?

John: Yes.

Sacha: Because you can specify it as a property.

John: So an entry has multiple categories— it's every parent that it has up the hierarchy.

1:22:58 TODO keywords use a fixed vocabulary

Karthik: Okay. The next is TODO keywords. I saw even HABIT was a TODO keyword for you, so I was wondering...

John: Oh yeah, I have a very fixed vocabulary of TODO keywords. If I share my screen again, the way that I manage my TODO keywords is that I have a dot-file. This dot-file defines my keyword hierarchy and how they're all related. The Org Haskell utility that I wrote that does the data normalization—this is how I tell it what my keywords are. I don't yet have Elisp code that also populates Emacs's Org-mode definitions based on this file, but I do it by hand— I guess because that data was older and it was already mostly there.

Karthik: And these are global across your whole corpus?

John: Yes, they're global. I don't ever use keywords outside of this set.

Karthik: Per-file keywords?

John: No, I don't use per-file keywords.

Sacha: Because you have your validation smacking it if it gets mistyped, for example.

John: Right.

Karthik: So to be clear, your TODO keywords represent the state of a task, right? Like, what state is it in? Hence the state machine right here, right?

John: Exactly.

Karthik: Okay. And the states include things like SCRAP or LINK. Why is LINK a state?

John: LINK is because it's a different kind of a note. A LINK is a note that only has a URL.

Sacha: So it doesn't require—yeah, your action is just look at the thing or do something with it.

John: Yeah, it has no body.

1:24:48 Tags are context: person, place, or thing needed for the task

Karthik: The next question is tags. How do you think of tags in Org?

John: Tags for me are context. They indicate the person, place, or thing that has to be present in order for me to be able to make progress on that task.

Karthik: And how is that different from— oh, okay, I can see how it's different from the category, I guess. So what are some examples of tags you use? I understand people's names are tags, but what else do you have there?

John: I have "call" as a tag, so it has to be during the times of the day when I could make a phone call. I have "errand" as a tag—it has to be during a time of the day that things would be open and I could drive out of the house. I have tags for individual people, so that I have to be able to be in contact with them. Org-mode has a nice feature: if I hit \ RET, it will examine my environment based on the name-mask-list-at Emacs Lisp function that I wrote, and it will auto-filter out the tags that don't currently apply. So if I have a tag based on "call" and it's outside of the time of when it could happen—like at 7 AM— then it will filter all the call items out of my daily agenda. They're still in the daily agenda; they just won't appear until later when it is time to make calls.

Karthik: Ooh. Okay.

1:26:14 Priority: A means must do, C means optional

Karthik: So the next affordance is priority. I guess you use priority the normal way— just A, B, C—for importance.

John: Well, I only use A and C. I don't use B.

Karthik: Okay, so you only need two, I guess. So what does it mean if it doesn't have a priority? Is that the lowest?

John: No. If it doesn't have a priority, that's just... So to me it's "must," "should," and "optional"—those are the meanings of the three priorities. "Must" means there is a consequence if you don't do it. "Should" means maybe you're missing out on an opportunity if you don't do it. But really, it's up to you. "Optional" means there's really no good or bad here; it's just an item you may want to do.

Karthik: So if it doesn't have an explicit priority, is it optional?

John: If it has no explicit priority, it's a "should."

Karthik: Okay.

John: I assume that if I made a TODO entry, it's something I should do. That's the assumption.

1:27:31 Properties are mostly automatically assigned metadata

Sacha: Do you use properties for anything? Aside from the review property, of course, do you have any other custom properties you like?

John: Just the ones I showed after we did the capture, like the ID, the location, when it was created, when it was modified.

Sacha: Yeah, so those seem to be more automatically assigned.

John: I very rarely use manually assigned properties.

Sacha: Okay.

John: To me, properties are metadata, so I'd rather just never look at them and have the system automatically manage them.

Sacha: I don't think we actually touched on what you do with a hash. Did we talk about that one yet?

1:28:09 The hash

John: The hash is how the database knows that an entry needs to be fully updated. If the hash has changed—the database has the hashes in it as well, and it has the last modification dates as well— first I do a search for all items whose modification date is different from the modification date in the Org-mode file, and then I check the hash values, because maybe I changed an item but I changed it back, and now the database doesn't need to be updated for that.

Sacha: Very cool. All right, so that's all the different Org features and how they support your workflow.

John: Yeah.

1:28:51 Assigning the tags when refiling

Karthik: Yeah, the one that's most interesting to me is tags, because I understand in the abstract what you mean by "a tag is a context or a resource that you need." But somehow I can never seem to implement it. It's not that I end up with a pile of tags that don't mean anything; it's that entries just don't get the tags that they need, so they don't show up later. Is there some way you ensure—when you capture, I know that you don't assign tags, you just want to get stuff in— at what point does it get assigned the right tags, and how?

John: Usually when I'm refiling it from the inbox into the appropriate category, into the appropriate heading.

Karthik: So do you do that by hand?

John: Yes, I always do that by hand. That's my main way of interacting with the task. I go to the inbox and then I give it the tags or the properties I want it to have.

Sacha: Are you using the standard Org completion for tags, or typing it in manually, or doing something to help you select from the gazillions of tags you probably have?

John: Yeah, I use—let's see, where is it in my Org-mode file here? I use the Org-mode feature... where are tags? Let me see where tags get defined, because I know I have the shortcut defined somewhere here in my Org-mode file. It says that "call" is the letter C.

Sacha: Oh, yeah.

John: I forget how Org defines that.

Sacha: That looks like that org-tag-persistent-alist there.

Karthik: That's C, yeah.

John: Yeah, but that's only a couple of tags.

1:30:47 Per-file tags and tag validation

John: Tags are one thing where I do tend to use in-file. If I want to have shortcuts for tags, I tend to use—so I have some tags that are truly global, and then I have per-file tags because I want the tags to be related to the categories that I'm tagging. My org-jw Haskell utility recognizes a file property called tags-all. If that file property is set, it will mandate that the tag has to be within that vocabulary.

1:31:29 Starting tasks with a restricted set of verbs and validating them

John: The same with verb-all. Verbs are words that can be at the beginning of an entry title that are followed by a colon.

John: So I might have, instead of "send an email to Sacha," I might say "Reply: Sacha's email." Instead of saying "reply to," I just make it a command verb. That verb has to be within that constrained vocabulary.

Sacha: That's interesting. Do you use those verbs for further filtering?

John: Yeah, because then you can search. They stand out a little bit better because they represent actions that need to be taken, and it's very clear what the action is. You could also query for all of the items that have a certain verb type. Like if I'm sitting down to write a bunch of emails, I don't have a tag for writing email and I don't have a category for writing email, but if I were to search for all items that have a "Reply" verb, I would find all of the emails that I need to write today.

Karthik: Is that just a text search, or do you search for...?

John: It's just a text search. Yeah, because colons don't get used in any other way. That's also a constraint of the system: where other people would use colons, I just use em dashes.

Karthik: Okay. And if I understand your system right, you wouldn't tag this entry with "Sacha," right? Because you don't need Sacha for this task.

John: That's correct. Unless Sacha would be the one writing the email, I don't need Sacha to write the email.

Sacha: Okay. Very interesting.

1:33:08 Searching items: ripgrep, vector embedding, openclaw

Karthik: So if you want to get a list of all your interactions with Sacha that have been captured in your Org database, would you just use full-text search with a name, or a semantic search with a name?

John: That's a really good question.

Sacha: You just removed two of the tasks, so we can put some back so that there's something to search.

John: Well, I would first use ripgrep, because that's the fastest.

John: But it all really depends on what it is that I'm looking for, because I have lots of—Sacha occurs a lot of times in my database. I don't have any way of saying, "What are all of my tasks related to Sacha?" unless she were a category. If she were a category, I could do it. But I don't have categories for every single person that I know.

Karthik: Okay.

Sacha: Okay, cool.

Karthik: So even with this extensive system, there are views that are not readily available?

John: I mean, I would probably at this point ask OpenClaw, "What are all my tasks related to Sacha?"

Karthik: Yeah. That's the semantic search doing its job.

John: Semantic plus full-text.

Karthik: Yeah.

John: Actually, let's see what it says. You know what? Actually, I shouldn't just have semantic search doing vector embedding here. I should actually have this able to engage a local LLM from Emacs, instead of just from OpenClaw.

Sacha: We see a TODO appearing real-time as John thinks, "Okay, I've got to add this to the system."

John: Yeah, I'll wait until the need increases.

Sacha: Yeah, yeah. But yeah, once you have the data, especially if you've got it indexed in something like Postgres that can do things a little bit faster, then yeah.

John: So this was its list of all tasks related to Sacha Chua. It didn't do a very good job.

Sacha: Because semantic—you know, vector search and names doesn't make sense. But if you're doing something more concept-related, that might work.

John: Yeah.

Sacha: Full text would be great. I think org-ql is something that people often use for that sort of thing anyway.

1:35:36 Linting and normalizing data in a pre-commit hook using Lefthook

John: Then finally, I use Lefthook, which is a Git hooks manager, so that when I type "changes"— which is going to make a commit whose subject line is just "changes" (I don't try to give descriptive commits for my thing)— it will use Lefthook to run the pre-commit hook, which is going to use the linter and use the org-jw Haskell. So it's now doing full round-trip lint on just the files that changed, by the way, not on all of them.

John: That succeeded, so it made the commit. Now that it's made the commit, it's going to store all of the changed entries in the database. Then it's going to do vector embeddings on all of the text regions that need up-to-date embeddings.

Sacha: I think this whole normalization piece is something that I would love to see if we can get into a form that somebody other than you can run, because it's one of the things I've envied about your system for a while.

1:36:40 LLM-generated RFC-style specifications of the format

John: I did finally write it all. I had AI help me create an RFC-format document for the entire Org-mode format. So this documents as a standard the Org-mode text format. Then this document is an RFC-format document which is the delta—everything that I do that is different or adds on to the Org-mode format is in this document. We could see, like, keywords. Not keywords, what do I call them... Verbs.

1:37:17 The heading grammar

John: So like here, this is the extended heading grammar. This shows exactly what can be in the heading of an Org-mode entry in what order. There is no syntax for headings in the Org-mode standard, but there is one in the JW extensions. So my org-jw Haskell project really is just an implementation of this RFC document.

Sacha: I see, because you've constrained your vocabulary so that, for example, your headings are verb-colon-whatever, and that can be verified by your Haskell program.

1:37:52 A TODO example with everything

John: Exactly. You can see down here an example that uses every feature. It's got the keyword, the priority. It's got the context, which is a special type of context—usually relating to accounts or things like that. If it's related to a bank, or actually if Sacha were the one who asked me to write the email, I might make Sacha be the context of the task. Then there's the verb, then there's the title, then there's the locator.

1:38:27 Locating objects in the physical world with {text}

John: The reason I use a locator is that in my closet I have a hanging files folder, and every file has a letter of the alphabet on it, A through Z. So if the task has—let's see here—if the task was "send email to Sacha" like this, this is an indicator to me that there is information related to this task that's in folder A of the hanging files folder. So sometimes if I have to send my property taxes into the county— well, they sent me a form to fill out and post with my check, so that form has to live somewhere while the task is open. Closed tasks, it's okay that their locator becomes invalid, because then I take the item out of the hanging folder and I shred it. But while the task is open, the locator locates related information, even if that information is physical.

Sacha: I'm always very interested in the interaction between digital and physical systems.

John: Yeah, I might say "garage" to locate something in my house, that there's an item in the garage.

Karthik: The typical approach to this would be to use an Org property that says "location" or "physical location," but I guess because you require properties to be managed...

John: Yeah, I don't see properties. To me, they can't hold actionable information.

Sacha: So what I'm taking away from this is "stuff more useful metadata into titles."

John: Or put a tag in the title that tells me that there is useful metadata, like the link tag.

Sacha: Yeah, yeah.

John: I could have a "phys" tag, which says that there's a locator to a physical something in the property. Or what's another one I use? It just occurred to me a second ago, but now I've forgotten it. Whatever. But yes, I could use that more too.

1:40:37 Managing attachments: DEVONthink for long-lived files, org-attach for temporary ones

John: Oh, attachments. I also use Org attachments. If somebody sends me a PDF, if that PDF is long-lived, I'll put it into a file-retrieval database called DEVONthink. Then I have a package for Org-mode, of course, called org-devonthink. If I just have the item selected in that database, I can hit a key which will associate a link that goes to that unique entry within the database. But if it's short-lived, meaning that I only need the PDF as long as I need the task to be open—kind of like with locators— then I will put it into an Org attachment, and that lives within a git-annex-controlled Git data directory within my Org-mode, sea of Org-mode data files. It gets a tag, which is capital FILE instead of capital LINK, which tells me if I open the attachments directory for this task, I will see something related to the task.

Sacha: Interesting.

1:41:45 Tags hint at where you can find more information

Sacha: So the tags also include hints about where you can go for more information.

John: Yeah, and those tend to be all uppercase— those sort of metadata-awareness tags— whereas the "call," "errand," blah blah blah are all capitalized words, as are all of the ones for people.

Karthik: About the link tag, sorry—you have LINK as the TODO keyword. You also have a link tag. Yes. Do they mean different things?

John: The LINK keyword means this is equivalent to a note that has a link tag but no body.

Karthik: Sorry, what am I looking at on your screen?

John: Oh, you're not looking. I'm not showing you anything.

1:42:31 :LINK: tags indicate that there is a link; LINK state says this note is only a link

John: So if I have a note that has a body and it has a URL, then it has to have a link tag.

Karthik: Oh, okay. This is just putting it into practice.

John: If there is no body, then it's this. It's just a contraction.

Sacha: It says, "Don't bother looking in here for a body."

John: Yeah, right. There's no supporting information here. This is a bookmark link. But if it's a note, then it's a note with a link attached. It's a question of: is the link the principal piece of information, or is the link the ancillary information?

Sacha: So the link tag says you can use C-c C-o on this and have something useful happen. The LINK type, or the LINK TODO state, says, "I'm just the link, I don't have any other notes."

1:43:30 Some other code turns Firefox bookmarks into an Org Mode file

John: Right. I have some other code— I believe it's written in Python— that will turn my Firefox bookmarks file into an Org-mode file with a bunch of link entries. It does this so it keeps that file in sync. That way I can use Firefox as a bookmark manager if I want.

Sacha: Cool.

1:44:06 The format specifications are LLM-generated

Karthik: So I looked at the RFC and it's 3,600 lines. That's the delta. How long did that take you?

John: It didn't take me any time at all. I just asked Claude to write it.

Karthik: Okay. But then how do you know it got it right?

John: I don't know that. Even if I wrote it, I wouldn't know that I'd gotten it right.

Karthik: That's true. Yeah. But I was wondering, is that intended for humans?

John: Probably not. It's intended for people who are writing such a process for themselves, and they would only be reading one specific section of interest. There's no human being that would ever read that document front to back. Or you could feed it to an AI and have it create the same thing for you in Python or Rust or whatever language you prefer.

Sacha: It's a specification.

John: Yeah, and AIs do very well with specifications. One thing that I could do that would be interesting is to use that specification to create a compliance test, and then any application which is able to pass the compliance test would be an implementation of the spec.

Sacha: It also helps with your validation code, probably. Yeah, that makes sense.

1:45:30 Quick recap

Sacha: Cool, cool. Okay, so a whole bunch of things here that I am definitely looking forward to digging into further. I particularly like that idea of a draft—you know, kind of just capture the text and then have a menu of actions that you can do with the text, such as turning it into an email message or copying to your clipboard while saving a copy of it. That sounds very interesting. And then I can dig into all the other cool things that you do with breaking down tasks and identifying tasks out of transcripts. Many, many things to explore. Karthik, is your brain full too?

Karthik: Yes, my brain overflowed with both information and ideas. I knew about the Drafts thing because John told me last year, but I didn't get it. The demo really helped with that in particular. Yeah, this was a whirlwind tour of...

1:46:28 A quick look at Github repositories: org2jsonl

John: So in my GitHub, you will find—if you look for "org-this" and other utilities that I use for managing Org-mode— there's another one I wrote called org2jsonl, which will take any Org-mode file and turn it into a list of JSON objects. That's because there are certain utilities like Beads for managing tasks for AIs, and this allows you to use Org-mode as the data format for that. I have a Rust implementation of Beads that I cloned from somebody else that I modified to use org2jsonl, so it manages the tasks database there. We talked about org-hash, org-drafts.

1:47:16 org-gptel: chat with AI within Org Mode instead of having to leave it

John: I use ob-gptel so that in my lab notebook especially, I can dialogue with AI within Org-mode, not having to leave Org-mode and go to some other client. I have a now a running dialogue with the AI in my Org-mode file.

1:47:35 obr: fork of Rust port of Beads to use Org Mode for issue lists

John: obr is the task management tool that uses Org-mode as the storage format. We talked about org-devonthink.

1:47:45 org-context saves metadata when refiling to allow restoring the task to its original location afterwards

John: Oh yes, I use org-context a lot as well. I never mentioned that one. This is another way that I use metadata. If I'm on a task, I can be on the stars of that task and type a short key. So w will refile a task somewhere else into another Org-mode file. When you refile a task in my system, it will supply it with a rich set of metadata identifying where the task came from. That's what org-context does. It doesn't do that for items that you refile out of the drafts inbox, because I assume that everybody came from the drafts inbox. But if it goes from the inbox to another file and then to another file, it'll know it came from that previous file. This can happen, for example, if a work task becomes an open-source task. Using org-context, this process is reversible. You can go to a task and say, "You know what? Unrefile yourself back to where you were." It uses that metadata to put itself back.

Karthik: Does this also work when you archive entries?

John: org-context advises on top of the archive mechanism to do the same thing for archiving that it does for refiling, by thinking of archiving as a form of refiling. So it allows you to unarchive a task back to where you archived it from.

Karthik: Yeah, because that's...

1:49:13 org-context use case: moving packing lists to the phone and back

John: The main reason I wrote it and that I use this system is that I use the iPhone app Plain Org for maintaining a list of items that I want to have access to as Org entries on my phone. So I have a special file called mobile.org that has its own little tiny hierarchy of just the items I want to see on my phone. But an Org entry can't live in two places, and it doesn't make sense for the phone version to be a link to the computer version because it doesn't have access to the computer. So what I do is, for the duration of time that I want it on the phone— and usually this is packing lists, actually, because I want to do the packing list on my phone— I will refile it into mobile.org. Then when I mark it done, I will unrefile it back to where it came from, which is typically a trip. One of the capture templates I have is for trips, where it will include "get a hotel," "get a flight," "do this," "do that"— it just is like a stock body of ten tasks that are associated with every trip that I ever take. Every time I do a trip, one of those tasks is a packing list task with a huge checklist underneath it. I will file that into mobile.org and unrefile it back.

Karthik: I see what you meant by "don't ever have only one system, only ever use Org, put everything in Org." You can't have a packing list somewhere else that's full of things to do.

John: I wouldn't have two. It has to live in this.

Karthik: Yeah, yeah, I know. I mean, that's one of the—I mean, that is a tooling problem. So there's a psychological problem, I think, with me trying to do things with Org, where present-me and future-me don't agree on what needs to be done and when, right? Org can't help with that. Then there's a tooling problem, which is just how do I see the things I need to see on my phone when I need to see them? At least as far as the tooling problem is concerned, you've got it all sorted.

John: I'm getting there! Little bit by little bit.

1:51:22 org-agenda-overlay

John: Then lastly, org-agenda-overlay. This is what causes the background colors to differ among my org-agenda items. org-agenda-overlay allows you—as a property, or as a file property, or as a defined Org-mode variable— to associate categories. I don't... maybe I even can associate tags. It might be arbitrary items, but you can associate it with a face property. Then you can specify in the face property any modifications to the Emacs face that you want to make. I have it set so that—I think I do this by... yeah, I do it by... Are you seeing my Emacs at the moment?

Karthik: Not yet.

John: Let me show you the Emacs. So I do it with org-todo-keyword-faces. Then I also do it with—oh, I think that's the only one I do it for. But you can see here—no, that's the colors of the keywords. Sorry, let me go here. It's under, of course, my org-agenda-overlay use-package declaration.

John: So I have org-agenda-overlay-by-file-tag. If the file has this file tag, then it will apply this background and foreground to any task from that file.

John: Then this is overlay-by-olp, which is the outline-level path. If it's in a heading called "inbox" (and of course this supports slashes so that you can be more specific), then alter the face. But you could do this with properties on the individual entries as well, if you wanted to.

1:53:05 john-wiegley-theme defines a palette

John: I created—let me see, what did I call it?—oh, john-wiegley-theme. I love to use rainbow-mode to help me edit this file. I wanted to create a consistent color vocabulary for everything that is in Org-mode. So all Org-mode tags, keywords, background colors, everything is harmonized to use these sets of colors. I have dark, darker, and darkest variants because of my black background.

Sacha: Interesting.

John: Yeah, I used a Mac app called Paletton to help me create the harmonious color wheel that these are chosen from.

Sacha: Okay, just a quick check. In terms of getting stuff out of this conversation in two forms that other people can learn from— if we're thinking of the audio recording and the transcript—we didn't talk about anything really weird. So is that reasonably good to go, or do you want to review it first?

John: No, I would ask the AI to let me know whether there was anything in the transcript that I wouldn't want to become public.

Sacha: All right. So basically, we do the transcript, we break it up into chapters so that there are timestamps, you have your AI say whether we should need to take stuff out. I was thinking maybe we do the transcript, possibly the audio recording, because it's fun to hear people be excited about stuff—and then you can imagine your cadence as you're talking about things. Then we can progressively enhance it with screenshots or clips or whatever Karthik has patience for. I don't know if we're going to do the full whole length video, but definitely bits of it.

Karthik: I'm going to start, and then I'm going to see how it's going. If it looks like I just have to draw rectangles over things—let me do like ten minutes of the video by hand and see if it took a reasonable amount of time. If it did, then I can extend that to the whole video. Otherwise, we will probably have to downgrade to screenshots or something where it's safe and easy to redact stuff.

Sacha: And then we can send— Karthik will coordinate with John about whatever else needs to be removed.

Karthik: Yeah. So John, I'm going to ping you and ask you, "Is this okay to include? Is this okay to include?" I'll try to batch these queries so you can give me—I'll try to be conservative, but yeah, let's see. In any case, I will share the video with you. No one is publishing anything until you give me the okay. So I think the transcript and audio stuff, Sacha, that's on you.

Sacha: And the text. Yes.

Karthik: And the video thing—drawing rectangles and adding blur filters— I will get started on that.

1:56:16 Some numbers: 83 packages just related to Org Mode

John: I just looked at my Emacs init file, and I realized that I have 83 different packages being configured that are related just to Org-mode. There's a lot being layered on to Org-mode. I didn't talk about org-contacts, I didn't talk about org-edna, I didn't talk about vcard or inline-task—all of these are things that I use very heavily. Like org-noter—org-noter is my primary way of taking notes on PDF files.

Sacha: You know, if we spend like five minutes where you just rattle off this list of modules you have, with like a one-line description—beyond the package description— of how it fits into your workflow...

John: I don't even remember what they all do.

Sacha: That's true. Yeah.

John: org-transcription I use, like, oh my gosh.

Sacha: A topic for another conversation.

John: Yeah, I think it's another—

Sacha: I think that's one of the fun things that we had back when we did the first Emacs Chat: just going through the configuration. Because when you're looking at it, you're like, "Oh yeah, that package, this is how I use it," or, "Oh yeah, I totally forgot about that one." So at some point we can do a walkthrough that's got config so you can say, "Oh yeah, this is what I use for this."

Karthik: Just use-package block after use-package block.

John: Yes, that's right. One after the other.

Sacha: But it doesn't have to be today.

Karthik: Yeah, definitely not. Yeah. I think Sacha and I have our hands full trying to get this video ready to be published.

John: Yeah. Well, at least I think we scratched the surface. I think we covered some of the big, broad strokes.

Sacha: Yeah.

Karthik: Yeah, I would say so.

Sacha: So this was a great idea. And thank you for taking the time to do it.

1:58:05 Org Mode inspiration

Karthik: I hope people get an idea of what's possible with Org-mode, because the common problem is that people say, "You can do everything, you can manage your life in Org-mode," and then when someone asks you to show how, you see some very anodyne, pedestrian things like to-do lists, and that's not what we're talking about. That's not the scale of things. Yeah, yeah, yeah. "And don't forget the milk," and this and that. No, that's not...

Sacha: Yeah, no, that's why we should talk about... 40,000 entries—what were you saying... 9,700 tasks and 1,200 of them are open. Yeah, that's the kind of scale we're looking at.

Karthik: And it's been maintained for 20 years at least.

1:58:51 Statistics

John: Actually, let's see, talking about— Let me share my terminal because I haven't looked at this in a little bit.

John: So if we go into my Org and I type make stats.

John: So this is 3,170 files, 40 megabytes of data. Oh, it is over 40,000 entries now.

Sacha: Yeah, yeah, yeah.

John: 28,000 are TODO items.

Sacha: Okay, okay. Well, let's update that.

John: 818 are open. So more than half of my Org-mode entries are TODO items.

Sacha: Very cool. And somehow the combination of org-ql and the Postgres database makes it easy to just fly through all of those files looking for the ones that you need.

John: I mean, "easy" is a very charitable word.

Sacha: "Fast," at least.

John: Oh wow, I have three items that actually have B priorities. I wonder what those mean.

Sacha: I'm surprised that your validation and normalization functions let those slip past you.

John: I don't think I disallow B. I think I had B have a specific meaning at one point, because B stands out so much. I had ascribed it to some special meaning.

Sacha: I like your stats. They're fun.

2:00:18 Most-common properties: ID, CREATED

John: Yeah. Look at that. My most commonly occurring properties are ID and CREATED. That's right, that's what it should be. Oh, but not every entry has a hash, clearly. I wonder how that happened.

2:00:33 Log entries are useful for notes by date

John: And we didn't talk about how useful log entries are. That's actually— I did try to veer away from Org-mode in like 2010, and the reason I couldn't was because log entries are too useful.

Sacha: Oh, now I'm really curious.

John: Yeah. Just the ability—while you're working on it— you know, some tasks live a long time. There was a time when Aetna wouldn't honor one of my insurance claims and it took me nine months to resolve it with them. But every single time I talked to them on the phone or by email, I would log an Org-mode note of what we talked about and who I talked to. So as time went on and I would get on the phone with a new person, I would be like, "Well, on this date I talked to this person and they said this. Then on this date, this person said this." I would overwhelm them with so much concrete information about how much I had done to resolve this, that they would be like, "Okay, okay, I get it."

Sacha: This person keeps receipts.

Karthik: How did you get that log into Org-mode? Were you on your computer while you were on the phone with them?

John: Yes, I was on the computer while I was on the phone.

Karthik: Okay. I'm just wondering, that's the kind of thing I could never manage, because I don't know where I'll be on the phone. I won't be near Org-mode.

2:01:48 Transcripts are great too

John: Well, nowadays the iPhone lets you record your phone conversations. So you can ask them if it's okay to record, and then—hey, AI is your friend.

Karthik: Okay.

John: I love transcripts now. I use them for all kinds of things.

Sacha: I agree. Transcripts are wonderful.

John: Yeah. And I record them all. Every meeting file, if I can, I just put the whole transcript in the file, because it helps with searching in the future.

Sacha: Yeah. All right. And on that note, we are going to turn this into a transcript and possibly [video].