notes from /dev/null - emacs

Revisiting Emacs Keyboard Macros with a Mouse

2026-06-04T09:35:00-07:00

“No-code automation” has been in Emacs far longer than its usage as a term of art. Better known as keyboard macros, this feature has allowed Emacs users to achieve their bespoke needs for decades, all without needing to know a whit about Lisp. I can testify to this personally: though I’ve been using Emacs since the early 90’s, only in the past three years has writing Elisp played any part in it. For most of my Emacs journey, I got by with just making keyboard macros.

If you’re unfamiliar with them, here are two links you should get to know:

The official Emacs manual for keyboard macros ((emacs) Keyboard Macros)
Mickey Petersen’s post - “Keyboard Macros are Misunderstood”

My addition to the knowledge of those posts is to boost this fact: mouse events can also be captured by a keyboard macro. If you know where a command is in a menu, you can also record clicking on it. I think the ability to combine both keyboard and mouse events in a keyboard macro is compelling, so much so that I decided to emphasize this in Anju.

The recent Anju v1.5.0 release added the menu “Tools › Macro Recorder” to the menu bar as shown below.

With this, mouse enthusiasts can create and run keyboard macros without need to recall keybindings or deal with inconsistent command naming, as observed in Petersen’s post.

One thing that I TILed about keyboard macros in building this menu was the command list-keyboard-macros (see (emacs) Kmacro menu). This command is available in the “Macro Recorder” menu as the item “List macros”. This lets you manage multiple keyboard macros that have been defined during a session.

If this interests you, I invite you install Anju from MELPA and give it a try. Let me know what you think!

Opening macOS Finder Folders in Emacs with Scrim

2026-06-01T19:00:00-07:00

TL;DR

If you use both Scrim and Emacs on macOS, you can “Open in Emacs” a file or directory from Finder via the “Quick Actions” context menu. This is implemented as a macOS Shortcut, shared as an iCloud link:

“Open in Emacs” Shortcut iCloud Link

Motivation

I find macOS drag-and-drop operations from Finder to Emacs (in particular, the NS variant) to be frustratingly inconsistent.

Dragging a file or folder from Finder to a non-Dired buffer will visit it.
- Not always! This behavior can be mode-specific.
Dragging a file or folder from Finder to a Dired buffer will copy it.
Dragging a file or folder from Finder to the Emacs icon in the Dock will visit it in a new frame.

Add to that, drag-and-drop isn’t graceful with a long traversal path on a large screen.

Ultimately, what I want is a single consistent action to “Open in Emacs” a file or directory from Finder. This post describes a solution for achieving this using the Scrim and macOS Shortcuts apps.

Background

Scrim

Scrim is an Org protocol proxy app that I had published on the App Store last year. Implementing Scrim was largely an exercise in reverse-engineering emacsclient to be a macOS app. This is because macOS apps these days (macOS 10.14+) are packaged to execute as a hardened runtime (aka “sandboxed”). Among the many things a hardened runtime restricts is the ability for an app to exec another program outside of its sandbox (like emacsclient).

In lieu of that restriction, macOS provides different APIs to let apps work with other apps, among them Services (more below), Intents (a whole different topic worthy of another post), and custom URL schemes.

A custom URL scheme is what Scrim provides to allow other apps to do emacsclient-like things like opening a file. By design, Scrim does not surface all the capabilities of emacsclient such as arbitrary Elisp execution. The custom URL scheme itself is scrim://.

Currently the scrim:// URL scheme supports the following two actions:

Visit a file or directory (e.g. scrim://open?file=~/.profile)
Open an Info node (e.g. scrim://info?node=(eshell) Top)

For this post, we will concern ourselves with (1) visiting (opening) a file or directory.

Note that on a system where a custom URL scheme is installed, any app on that system can open said custom URL scheme.

Services

The macOS Services API allows an application to access the functionality of another.

Apple uses this API to provide tools to help orchestrate workflows between different applications, namely AppleScript, Automator, and Shortcuts. Note that as of this writing, AppleScript and Automator are in maintenance mode, and Shortcuts is intended to supersede Automator. Once a workflow is defined, it is usually accessed via a context menu sub-menu labeled “Quick Actions” or “Services”.

“Open in Emacs” Shortcut

With the above background out of the way, let's turn our attention to the Shortcut itself.

The shortcut invokes a Python script which forms the scrim://open?file custom URL and then opens it with the open command line utility.

import sys
from subprocess import call
from urllib.parse import quote

buf = "scrim://open?file={0}".format(quote(sys.argv[1]))
cmdList = ['open', buf]
call(cmdList)

This shortcut can be installed via iCloud link: “Open in Emacs” Shortcut iCloud Link.

When installed, the menu item "Open in Emacs" will appear in the "Quick Actions" sub-menu when the context menu is raised on an Finder item.

“scrim link” Shortcut

What if you want just the Scrim URL to open a file or directory instead? The shortcut "scrim link" shown above provides that, putting the URL into the system clipboard to paste into another native macOS app like Notes or TextEdit. Such apps that recognize custom URL schemes will treat the URL as a “live” link.

This shortcut is available at “scrim link” Shortcut iCloud Link.

Closing Thoughts

While the behavior of "Open in Emacs" seems modest, a lot of things need to happen under the hood to orchestrate the different apps required to make it happen on macOS. But taking a step back, I'd observe that this is not unique to just macOS alone. Other contemporary operating systems are following suit as seen with Snap (Ubuntu) and Flatpak for Linux, and UWP for Windows. Such isolating practices by OS vendors are not going away.

Running counter to this is the spate of interest in orchestrating apps and/or services together using AI tools, whose approach so far is to bypass all hardened runtime boundaries.

Then there is comparison to the Emacs ecosystem, where orchestration of apps (or rather modes) is routinely done via Elisp. By implementation circumstance there are effectively no concerns for security boundaries within the internals of Emacs.

There's a lot of ground to ruminate on, in particular software malleability and orchestration, which I intend to do with future posts on this blog.

Anju v1.5.0 Update

2026-05-28T10:00:00-07:00

Heads up for readers of this blog who are using Anju or are mouse-curious Emacs users. I’ve recently released the v1.5.0 update for it, now available on MELPA.

Many new features and enhancements are in this update as outlined below:

Context Menus
- Enhancements to selected text
  - Query Replace (Regexp)…
- Enhancements to Org mode support
  - Headline
    - Change to Body
    - Sort…
  - Item
    - Cycle Bullet…
    - Sort…
  - Table
    - Sort…
  - Copy as…
  - Link…
- Added support for Makefile mode
- Added support for Info mode
- Added support for Compilation/Grep mode
Main Menu
- Tools menu enhancements
  - Global Org Commands
  - Macro Recorder
- Edit › Delete menu enhancement
  - Delete Duplicate Lines

Users who work with both Org mode and Markdown formatted text should find interest in the Copy as… capability added to the Org mode context menu. This feature lets one use Org mode as the primary means of authoring text, exporting to Markdown (or another format) using a right-click mouse copy action.

Thanks to Marcin Borkowski whose post “Org-mode to Markdown via the clipboard”, inspired this feature.

Anju also provides a complementary command “Paste Markdown as Org” for Org mode which lets one paste copied Markdown text into an Org file, doing the conversion of Markdown to Org under the hood using pandoc.

In summary, this is a big release with many changes. I invite you to explore all the links above to see what’s available in Anju.

Using the Mouse for Emacs Rectangle Commands

2026-05-18T09:45:00-07:00

Of all the built-in editing commands in Emacs, the commands that work with rectangles delight me the most. Once understood, they can save effort in many situations.

That said, the biggest downside to rectangles is the amount of setup it takes to use them. As with many things Emacs, by default you have to memorize a bunch of keybindings to get anything done with them.

In Casual, I addressed the above downside by providing a Transient menu for rectangle commands. Since building that, I've come to use rectangle commands routinely. But even then, there is ceremony to set up a rectangle selection.

With my recent work on mouse-driven interactions in Anju, I’ve learned that rectangle selection is trivial via C-M-<mouse-1> dragging. Once selected, having a menu of rectangle commands makes working with them even easier. So I made one for the latest v1.4.0 update for Anju, now on MELPA.

The “Rectangle” sub-menu is available via the main menu bar “Edit” menu (as shown in the screenshot above) or via context menu. Using rectangle commands in conjunction with the align-regexp (“Edit › Align Regexp…”) and whitespace-cleanup (“Edit › Delete › Whitespace Cleanup”) can make short work of editing text that is laid out in columns. Anju makes both of these commands available from the main menu.

Side note: on using C-M-<mouse-1>, sometimes Emacs will only read M-<mouse-1> and do a secondary selection, leaving an unwanted highlight. Enter M-<mouse-1> to dismiss the highlight.

If you find Anju to be useful, please support its development by buying me a coffee. I’ve got a number of new features planned for it.

Enhancing Elisp Development with Context Menus

2026-05-11T11:00:00-07:00

As celebrated as Emacs is for its programmability, I find the actual process of developing Emacs Lisp (Elisp) to be quite underwhelming. Developing in Elisp has meant learning its libraries and idioms, which is to be expected. What I really don’t care for though are the arcane keybindings associated with doing basic things like evaluating, navigating (Xref), and debugging (especially debugging). While I’ve already committed to muscle memory most of said keybindings, I’d argue that having a mouse-based “point and click” interface is beneficial for both novice and experienced Elisp developers alike, as it lets one focus on the code and not on recalling the right key incantation all the time.

The addition of context-menu-mode in Emacs 28 has provided the opportunity to build a mouse-based UI for Elisp development and I’m happy to announce the availability of one in the latest v1.3.0 update to Anju, now on MELPA.

To get an idea of what’s available in the v1.3.0 update, here’s a screenshot of the context menu when normally editing an Elisp file where the point is on the symbol foo.

If foo is instrumented for debugging and run, the context menu is adjusted to provide Edebug commands as shown below.

The context menu enhancements provided by Anju take full advantage of built-in functions that identify context at point. Is the point on a symbol? In a function? In an ERT test? On a lambda? The menu items added by Anju take these factors into account to provide a relevant menu offering.

Users can read more about Anju’s context menu enhancements for Elisp development at Emacs Lisp Context Menu (Anju User Guide).

Some backstory with Edebug

Back in 2024, I did a deep dive into Edebug so as to give a presentation on it at the EmacsSF meetup. In doing so, I realized that all the core features for having an Elisp IDE were there, but no good UI to present it. I set upon prototyping one using Transient, with decidedly mixed results due to both Edebug and Transient fighting each other over window management.

A later Edebug UI prototype using the toolbar was attempted but it also had its issues, particularly with layout (or lack thereof) and toolbar-specific bugs in macOS. But a benefit of using the toolbar was that its UI interactions did not interfere with window management. The context menu also shares this benefit.

Closing Thoughts

The context menu has markedly improved my developer experience with Elisp, as I find myself using it more than typing out keybindings. Even with keybindings, I’ll use the Casual Elisp Transient to accomplish most Elisp interactions that don’t require Edebug.

That said, I’m not here to eschew keybindings. I still use them, when convenient. But in many circumstances they are not. The context menu can provide an easier way to achieve the same thing. Isn’t that a good thing?

Bulk Search & Replace Commands for Files and Buffers in Emacs

2026-04-29T22:15:00-07:00

Emacs offers a dizzying number of commands to perform bulk operations on multiple files or buffers. These commands are quite capable and can make trivial the execution of workflows that would be heroic in other editors. Unfortunately these commands are also difficult to discover as a number of them are not featured in easily accessible menus.

This post calls attention to bulk commands related to search and replace in Emacs and how their discoverability can be improved using the Casual and Anju UI packages.

Regular Expressions

Before moving forward, let’s talk about how Emacs handles regular expression syntax in search and/or replace commands. Whenever using an Emacs command involving a regular expression (regexp), you will need to understand what kind of regexp syntax is expected. There are largely two to know:

Emacs
grep (implementation dependent)

Commands using grep-style regexps do so because they invoke the local install of the grep utility. The grep regex syntax is implementation dependent. If you use GNU grep, you can read its syntax here, which share some character classes with Emacs.

The Casual RE-Builder package is a great way to work with Emacs regexps as it provides a command to escape the regexp properly for interactive input. re-builder alone only provides a regexp that can be used in Elisp code.

Bulk Search & Replace Commands

The table below shows the different search and/or replace workflows and their associated commands.

Workflows	Command	Regexp Type	Notes
Search regexp in files in directory	rgrep	grep	AKA “Find in Files.” Results can be edited using writeable grep (wgrep).
Search regexp in files in project	project-find-regexp	grep
Search regexp in files in directory and present in Dired	find-grep-dired	grep
Search regexp in tagged files	tags-search	Emacs
Search file names matching shell pattern in directory and present in Dired	find-name-dired	shell
Search file names matching regexp in directory and present in Dired	find-lisp-find-dired	Emacs	Implementation uses Emacs regexp type.
Search file names matching regexp in current directory and present in Dired	casual-dired-find-dired-regexp	Emacs	Wrapper around find-lisp-find-dired using current directory. Available via Casual.
Query replace regexp in project files	project-query-replace-regexp	Emacs
Incremental search marked files with plain text	dired-do-isearch		For use in Dired.
Incremental search marked files with regexp	dired-do-isearch-regexp	Emacs	For use in Dired.
Query replace regexp in marked files	dired-do-query-replace-regexp	Emacs	For use in Dired.
Search regexp in marked files	dired-do-find-regexp	grep	For use in Dired.
Search regexp in marked files and display first match	dired-do-search	Emacs	For use in Dired.
Replace regexp in marked files	dired-do-find-regexp-and-replace	grep	For use in Dired.
Replace regexp in marked files using diff interface.	dired-do-replace-regexp-as-diff	Emacs	For use in Dired.
Incremental search marked buffers with plain text	ibuffer-do-isearch		For use in IBuffer.
Incremental search marked buffers with plain text with regexp	ibuffer-do-isearch-regexp	Emacs	For use in IBuffer.
View lines which match regexp in marked buffers	ibuffer-do-occur	Emacs	For use in IBuffer.
Query replace plain text in marked buffers	ibuffer-do-query-replace		For use in IBuffer.
Query replace regexp in marked buffers	ibuffer-do-query-replace-regexp	Emacs	For use in IBuffer.
Run git grep, searching for regexp in directory.	vc-git-grep	grep
Replace all references to identifier.	xref-find-references-and-replace
Interactively replace identifier in current xref buffer.	xref-query-replace-in-results
Rename symbol at point for project.	eglot-rename		Requires Eglot support.
Replace regexp in files using diff interface.	multi-file-replace-regexp-as-diff	Emacs
Start multi-buffer incremental search on a list of files.	multi-isearch-files
Start multi-buffer incremental regexp search on a list of files.	multi-isearch-files-regexp	Emacs
Start multi-buffer incremental search on a list of buffers.	multi-isearch-buffers
Start multi-buffer incremental regexp search on a list of buffers.	multi-isearch-buffers-regexp	Emacs
Show all lines in buffers containing a match for regexp.	multi-occur	Emacs
Show all lines containing a match for regexp in buffers that match bufregexp.	multi-occur-in-matching-buffers	Emacs

Choice of command depends on the quantity and specificity of files or buffers to work on. Both Dired and IBuffer marking allow for specific selection of files or buffers respectively.

Many of the commands in the table above are discoverable via menu using the Casual and Anju packages. Hierarchical menu categorization aids in the discovery and recognition of these commands, making them more usable.

Command	UI	Notes
rgrep	(C-o) casual-editkit-main-tmenu › (/) Search/Replace › (g) Find in Files…	Available via Casual EditKit.
rgrep	(Menu-bar) Edit › Search › Search in Files…	Available via Anju.
project-find-regexp	(Menu-bar) Edit › Search › Search in Project Files…
tags-search	(Menu-bar) Edit › Search › Search Tagged Files…
project-query-replace-regexp	(Menu-bar) Edit › Replace › Replace in Project Files…
find-name-dired	(C-o) casual-editkit-main-tmenu › (/) Search/Replace › (d) Files…	Available via Casual EditKit.
find-grep-dired	(C-o) casual-editkit-main-tmenu › (/) Search/Replace › (G) Files containing text…	Available via Casual EditKit.
casual-dired-find-dired-regexp	(C-o) casual-dired-tmenu › (f) Filter by name…	Available via Casual Dired.
dired-do-isearch	(C-o) casual-dired-tmenu › (/) Search/Replace › (C-s) I-search…	Available via Casual Dired.
dired-do-isearch-regexp	(C-o) casual-dired-tmenu › (/) Search/Replace › (M-s) I-search regexp…	Available via Casual Dired.
dired-do-query-replace-regexp	(C-o) casual-dired-tmenu › (/) Search/Replace › (r) Query regexp and replace…	Available via Casual Dired.
dired-do-find-regexp	(C-o) casual-dired-tmenu › (/) Search/Replace › (g) Find regex…	Available via Casual Dired.
dired-do-search	(C-o) casual-dired-tmenu › (/) Search/Replace › (s) Search first regexp match…	Available via Casual Dired.
dired-do-find-regexp-and-replace	(C-o) casual-dired-tmenu › (/) Search/Replace › (G) Find regex and replace…	Available via Casual Dired.
ibuffer-do-isearch	(C-o) casual-ibuffer-tmenu › (C-s) I-Search…	Available via Casual IBuffer.
ibuffer-do-isearch-regexp	(C-o) casual-ibuffer-tmenu › (C-M-s) I-Search Regexp…	Available via Casual IBuffer.
ibuffer-do-occur	(C-o) casual-ibuffer-tmenu › (O) Occur…	Available via Casual IBuffer.
ibuffer-do-query-replace	(C-o) casual-ibuffer-tmenu › (M-r) Query Replace…	Available via Casual IBuffer.
ibuffer-do-query-replace-regexp	(C-o) casual-ibuffer-tmenu › (C-M-r) Query Replace Regexp…	Available via Casual IBuffer.
vc-git-grep	(Menu-bar) Tools › Version Control > Git grep…

Refactoring Guidance

The replace commands can do catastrophic damage if not used with caution. Treat them like power tools.

Some guidance before using replace commands:

Have a backup plan in case you need to recover anything.
Use re-builder to help figure out the right regexp.
Know the scope of what you want to change (directory, files, buffers).
Some commands will only modify the buffer of an affected file. Check if modified buffers are saved. You can use IBuffer to identify and save such buffers. It is left as an exercise to the reader to determine which commands exhibit this behavior.

Closing Thoughts

The inventory of commands above are from what I know of Emacs, which is guaranteed to not be comprehensive. If there are others missing from this list, please let me know at kickingvegas@gmail.com.

While many of these commands have been in Emacs for years (decades even), they were not usable to me until I built a UI for them. I think motivated readers using Casual and Anju for bulk search and/or replace tasks will find a similar sentiment.

Amended 2026-04-30: Added vc-git-grep, eglot-rename, xref-find-references-and-replace, and xref-query-replace-in-results. Thanks to Henry Leach and Gene Pasquet for their input!

Amended 2026-05-04: Added dired-do-replace-regexp-as-diff, multi-file-replace-regexp-as-diff, multi-isearch-files, multi-isearch-files-regexp, multi-isearch-buffers, multi-isearch-buffers-regexp, multi-occur, multi-occur-in-matching-buffers. Learned about the diff commands from Christian Tietze's post Preview Mass Text Replacements with Emacs 30.1 replace-regexp-as-diff.

Some nice to know keybindings when using the mouse in Emacs

2026-04-24T13:40:00-07:00

These keybindings are good to know when working with a mouse in Emacs.

F10 (menu-bar-open) :: Start key navigation of the menu bar in FRAME.

S-F10 (context-menu-open) :: Start key navigation of the context menu. This needs context-menu-mode enabled.

C-M-mouse-1 :: Activate a rectangular region around the text selected by dragging. Useful for rectangle operations.

M-Drag-mouse-1 :: Set the secondary selection, with one end at the place where you press down the button, and the other end at the place where you release it. See Secondary Selection for more info.

C-mouse-3:: Raise menu populated with the menu mode map of the current mode and if Imenu is enabled, an index menu for that buffer.

C-u n (optional) :: A prefix argument can be passed to a menu item.

Keyboard Macro :: Commands issued via menu can be used when recording a keyboard macro. (🤯 Who knew?)

C-x z (repeat) :: Repeat most recently executed command. Yes, repeat works also for commands issued via mouse too!

Knowing that repeat works with menu commands (both main and context) is particularly useful with the additions to the main menu made by the latest Anju v1.2.0 update. Shown below is a demo of using “Duplicate” (duplicate-dwim) from the Edit menu, then using C-x z and then z successively to repeat the duplication.

Your browser does not support HTML video. Link to video.

Amended 2026-04-25: Added C-M-mouse-1, M-Drag-mouse-1, C-mouse-3, C-u n, Keyboard Macro items.

Call for Testing: Scrim v1.1.3 TestFlight on pre-release Emacs 31

2026-04-23T14:40:00-07:00

For folks who like using the development build of Emacs (at the time of this writing Emacs 31.0.5) on macOS, it turns out there is a bug in how Scrim sends Org protocol requests to it.

A fix has been identified and so far it works fine for both Emacs 30.2 and 31.0.5 from my testing. That said, it is always better to have more folks trying it out.

If you use the latest Emacs 31.0.5+ on macOS and use (or are interested in using) Org protocol, I invite you to try out a TestFlight build of Scrim v1.1.3.

If this is the first time you’ve heard about Scrim, learn more about it at http://yummymelon.com/scrim/

Thanks much!

Computing Days Until with Emacs

2026-04-08T16:00:00-07:00

A recent Mastodon post showing the days until the next U.S. election got me to wonder, “how can I compute that in Emacs?” Turns out, this is trivial with the Org mode function org-time-stamp-to-now doing the timestamp computation for you.

We can wrap org-time-stamp-to-now in an internal function cc/--days-until that generates a formatted string of the days until a target date.

(defun cc/--days-until (target &optional template)
  "Formatted string of days until TARGET.

- TARGET: date string that conforms to `parse-time-string'.
- TEMPLATE : format string that includes ‘%d’ specifier.

If TEMPLATE is nil, then a predefined format string will be
used."
  (let* ((template (if template
                       template
                     (concat "%d days until " target)))
         (days (org-time-stamp-to-now target))
         (msg (format template days)))
    msg))

From there we can then start defining commands that use cc/--days-until. The command cc/days-until shown below will prompt you with a date picker to enter a date. Note that you can enter a date value (e.g. “Dec 25, 2026”) in the mini-buffer prompt for org-read-date.

(defun cc/days-until (arg)
  "Prompt user for date and show days until in the mini-buffer.

Use `org-read-date' to compute days until to display in the mini-buffer.

If prefix ARG is non-nil, then the computed result is stored in the
 `kill-ring'."
  (interactive "P")
  (let* ((target (org-read-date))
         (msg (cc/--days-until target)))
    (if arg
        (kill-new msg))
    (message msg)))

Going back to the original motivator for this post, here’s an implementation of days until the next two major U.S. election dates with the command cc/days-until-voting.

(defun cc/days-until-voting (arg)
  "Days until U.S. elections in 2026 and 2028.

If prefix ARG is non-nil, then the computed result is stored in the
 `kill-ring'."
  (interactive "P")
  (let* ((midterms (cc/--days-until "2026-11-03" "%d days until 2026 midterms"))
         (election (cc/--days-until "2028-11-07" "%d days until 2028 presidential election"))
         (msg (format "%s, %s" midterms election)))
    (if arg
        (kill-new msg))
    (message msg)))

The result of M-x cc/days-until-voting as of 8 April 2026 is:

209 days until 2026 midterms, 944 days until 2028 presidential election

It’s so human to want to know how long it’s going to take. Feel free to build your own countdown clocks using the code above. May your journey to whatever you plan be a happy one!

Calming Mouse Interaction in Dired

2026-04-07T13:25:00-07:00

Conventional file managers have conditioned me to expect that a single left-button mouse click (<mouse-1>) will select a file (or directory) and double-click will open it. This is not the default behavior of Dired, where a single click is an open action. I find this far too twitchy for my taste.

This post shows how to make Dired mouse interaction align with a conventional file manager where:

Single-click on a file or directory will move the point to it, making it the implicit target for any subsequent Dired command.
Left double-click on file or directory will open it.
Selecting multiple files is emulated using Dired marking, in this case using the binding M-<mouse-1> to toggle marking a file.

The first two points above can be addressed with the global variable mouse-1-click-follows-link. Dired uses this variable to control its mouse behavior, but we don’t want to change it everywhere, just for Dired buffers. This can be implemented by setting mouse-1-click-follows-link locally as a hook to dired-mode-hook:

(add-hook
 'dired-mode-hook
 (lambda ()
   (setq-local mouse-1-click-follows-link 'double)))

To address multiple file selection, we can define a function cc/dired-mouse-toggle-mark and bind it to M-<mouse-1>.

(defun cc/dired-mouse-toggle-mark ()
  "Toggle mark of a Dired item via mouse."
  (interactive)
  (unless (use-region-p)
    (mouse-set-point last-input-event)
    (if (char-equal (char-after (line-beginning-position)) dired-marker-char)
        (call-interactively #'dired-unmark)
      (call-interactively #'dired-mark))))

(keymap-set dired-mode-map "M-<mouse-1>" #'cc/dired-mouse-toggle-mark)

Coupled with Anju support for a Dired specific context menu and many basic file manager operations can be done in Dired via mouse with minimal fuss.

Announcing Anju

2026-03-30T08:45:00-07:00

The recent post “You don’t not need the mouse” by noa ks speaks to a sentiment that I’ve had for some time. Using the mouse in Emacs can be a good, daresay delightful, experience. Unfortunately though, Emacs has antiquated default settings that presume we’re all still using a 90’s style 3-button workstation mouse. In addition, the overreliance on reusing menu keymaps for both the main and context menus results in poor user experience. I feel strongly that context menus populated this way feel more like an inventory than a thoughtful selection of commands relevant to context.

Thankfully, Emacs offers the mechanisms to sculpt mouse interactions to contemporary (circa 2026) expectations. Over the past three years, I’ve taken advantage of them to implement the following features:

Mode Line
- Right mouse click on blank space to pop-up a window management menu
- Left mouse click on buffer name to pop-up a customizable list of buffers
- Double click on blank space to toggle current window to maximize or return to prior window configuration
Context Menu
- Context-aware commands for selected text (use-region-p)
- Context-aware commands for Org and Dired mode
Main Menu
- Add Bookmarks menu
- Reorganize Help menu

Several months ago, I decided these mouse interaction changes should be generalized into a package that others could use. So began the Anju project.

Today I’m happy to announce that Anju v1.0 is now available on MELPA.

Learn more details about Anju in its User Guide.

As Anju is new, I’m always open to constructive feedback on it. Let me know what you think. Work on Anju is ongoing with the plan to keep adding improvements to it over time, in particular with supporting more context menus for different modes.

Casual now available on NonGNU ELPA

2026-03-03T13:10:00-08:00

If you are an Emacs user who only uses 3rd party packages from ELPA or NonGNU ELPA, I’m happy to announce that Casual is now available on NonGNU ELPA. 🎉

If this is the first time you’ve heard of Casual, it is a project to re-imagine the primary user interface for Emacs using keyboard-driven menus. Casual’s design intent is to make the vast feature set of Emacs easier to discover and use in casual fashion. It does so by providing bespoke hand-crafted menus for different modes provided by Emacs. These menus are opinionated in that the design of what goes into those menus are editorially determined by yours truly. To understand more about what Casual has to offer, please peruse its User Guide.

In terms of implementation, Casual is built using the Transient library made by Jonas Bernoulli. This is the same library that powers the UI for Magit.

Development of Casual has been on-going for nearly two years now. Interested readers can read about Casual’s progress over that time from my blog posts here. Throughout it all I’ve learned a lot about Emacs, its ecosystem of modes, and the powerful features they bring. It has only reinforced my conviction that Casual makes these powerful features more usable beyond what is offered by default in Emacs.

To clarify, if you still get Casual from MELPA (or MELPA Stable), you do not have to change anything. The only difference is that users can now choose to install Casual from either MELPA or NonGNU ELPA. Updates to Casual will be distributed on both equally.

My thanks goes out to the NonGNU ELPA reviewers who have provided guidance in helping get Casual on there. Additional thanks goes out to all the Casual users whose input and support have kept me going at this since 2024.

Announcing Casual Org

2026-02-19T15:00:00-08:00

Most Emacs Org users would concur that Org mode is a magnificent tool for capturing and communicating thought. That said, Org mode’s vast set of features can be daunting to master. A common guidance for new users is to take it slow: incrementally learn a subset of Org’s features as you need them.

A big reason for Org mode’s steep learning curve is that it adopts Emacs’ unfortunate culture of compelling users to memorize keybindings. Learning a distinct keybinding for each Org command (remember I said vast feature set?) is onerous, so a different tack is made: reuse the same keybinding but have it possess different behavior based on context. This context is usually tied to the type of structure the point (aka cursor) is in. For example, if the point is in a source block, the binding C-c C-c would execute it, but if the point is on a checkbox item, then C-c C-c would toggle its checked state. Taking this approach lowers the effort to recall a keybinding at the cost of recalling what its contextual behavior would be. In practice, using such overloaded keybindings is…okay. But I’d argue that we could have a more usable interface, leading to the point of this post:

Announcing support for Org mode in the v2.14.0 update for Casual, now available on MELPA.

Readers of this blog will know that Casual is my project to re-imagine the primary user interface for Emacs using keyboard-driven menus. If this is new to you, I highly recommend reading this introduction to it.

Primary to the design of the Casual Org menus is to be context-sensitive, only showing a subset of Org mode commands that are relevant. This set of context-sensitive commands is opinionated, but seeks to provide utility to users both new and experienced with Org.

Shown below is a demo of Casual Org at work:

Your browser does not support HTML video. Link to video.

While the design of this UI has been months in the making, there is nothing like real-world use and feedback. Constructive input is appreciated, especially if you are relatively new to using Org.

A great deal of thanks goes out to the maintainers of and contributors to Org mode and to the community that uses it. If you are able, please support it. Also, if you find Casual useful, I’d appreciate a coffee as well.

—

Video music: Burna Boy - Last Last (JON REYES FINDAWAY BLEND) | Jon Reyes

Deburring Emacs Imenu GUI Configuration

2026-02-10T09:20:00-08:00

A while back, I made a post on Emacs Imenu configuration that made an unsafe assumption that any mode derived from prog-mode would support Imenu. Turns out, that’s not always true (for example, looking at you gnuplot-mode). This post shows how to deal with this using an error handler.

One such implementation of an error handler is the lambda expression shown below using condition-case.

(add-hook 'prog-mode-hook
          (lambda nil
            (condition-case err (imenu-add-menubar-index)
              (imenu-unavailable
               (let ((inhibit-message t))
                 (message "Warning: %s" (error-message-string err)))))))

A couple of observations:

The error handler is opportunistic in applying imenu-add-menubar-index to a mode derived from prog-mode.
If the error imenu-unavailable is caught, then a warning message is logged but not messaged to the mini-buffer.
- The variable inhibit-message is used to avoid sending a warning message to the minibuffer (it will still be logged in *Messages*) to avoid noise from modes that do not support Imenu. (Thanks to bpalmer for this guidance.)

If you use Emacs and this is the first time you’ve heard of Imenu, I highly recommend that you learn what it has to offer.

Using Casual to work with Emacs Registers, Rectangles, and Windows

2026-02-07T10:00:00-08:00

The features of registers, rectangles, and window management in Emacs are quite powerful yet prior to building Casual, I rarely used them because of the cognitive load of remembering each feature’s command sets, much less their bindings. Using keyboard-driven menus tailored for these three features changed that. Now I only have to recall three key bindings to get easy access to registers, rectangles, and window management. This post demonstrates how you can as well.

Provided you have Casual installed from MELPA, consider making the following global key bindings to your Emacs setup:

(keymap-global-set "C-c r" #'casual-editkit-rectangle-tmenu)
(keymap-global-set "C-c g" #'casual-editkit-registers-tmenu)
(keymap-global-set "C-c w" #'casual-editkit-windows-tmenu)

As always, you can adjust these bindings to your preference.

Each of these menus are detailed further below.

Rectangle Menu (casual-editkit-rectangle-tmenu)

The rectangle feature gives you the ability to mark (select) an arbitrary rectangle region in an Emacs buffer. There are many times where if the text is shaped like a rectangle, making transformations on them is exceptionally convenient. This menu provides you this.

Registers Menu (casual-editkit-registers-tmenu)

Registers provide users a way to temporarily keep track of Emacs run-time state like text clippings, cursor (point) positions, macros, and arrangement of windows.

Registers are a distinguishing feature of Emacs from other applications that support writing. It’s definitely a feature I miss when working outside of Emacs.

Windows Menu (casual-editkit-windows-tmenu)

In Emacs vernacular, a window is a visual organization of how a buffer is displayed. Emacs windows are not the same as what conventional GUIs (e.g. Wayland/X11, Apple macOS, Microsoft Windows) refer to as windows. In Emacs, GUI windows are referred to as frames.

Emacs provides a number of commands to manage windows throughout their entire life-cycle which Casual organizes into the menu shown below:

In practice, I’ve found this menu to be most useful when using a compact/laptop-style keyboard or accessing Emacs via TTY. But if you are using GUI Emacs with a keyboard that has a number-pad, consider making the following number-pad bindings, particularly for selecting focus and swapping windows.

;; Number pad bindings for window management.
;; Requires GUI Emacs.
(keymap-global-set "C-<kp-add>" #'enlarge-window)
(keymap-global-set "C-<kp-subtract>" #'shrink-window)
(keymap-global-set "M-<kp-add>" #'enlarge-window-horizontally)
(keymap-global-set "M-<kp-subtract>" #'shrink-window-horizontally)
(keymap-global-set "C-<kp-enter>" #'other-window)
(keymap-global-set "M-<kp-enter>" #'switch-to-buffer)
(keymap-global-set "C-<return>" #'other-window)

(keymap-global-set "C-<kp-8>" #'windmove-up)
(keymap-global-set "C-<kp-5>" #'windmove-down)
(keymap-global-set "C-<kp-2>" #'windmove-down)
(keymap-global-set "C-<kp-4>" #'windmove-left)
(keymap-global-set "C-<kp-6>" #'windmove-right)

(keymap-global-set "M-<kp-8>" #'windmove-swap-states-up)
(keymap-global-set "M-<kp-5>" #'windmove-swap-states-down)
(keymap-global-set "M-<kp-2>" #'windmove-swap-states-down)
(keymap-global-set "M-<kp-4>" #'windmove-swap-states-left)
(keymap-global-set "M-<kp-6>" #'windmove-swap-states-right)

;; These require the `ace-window' and `transpose-frame' packages.
(keymap-global-set "C-<kp-0>" #'ace-select-window)
(keymap-global-set "C-<kp-divide>" #'transpose-frame)

Note that the bindings for ace-select-window and transpose-frame require that you have the ace-window and transpose-frame packages installed.

Closing Thoughts

Registers, rectangles, and managing windows in Emacs are powerful features that are made easier to use with Casual. If you haven’t explored them, consider trying them out. I think you’ll be pleasantly surprised by what they offer and over time will consider them essential to your Emacs experience.