• Package name (GNU ELPA): modus-themes (also built into Emacs 28+)
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

5.3.0 on 2026-06-21

The Modus themes are in a stable state. To my mind, they provide the best “default theme” experience across the 40+ original themes I have carefully designed.

Modus is also a platform for making themes for Emacs. There are plenty of derivatives already. I am linking to them through the project’s README.md and am always happy to mention more packages—just let me know.

This version does not include many user-facing changes. Most of my work focused on making internal refinements.

Load the themes through the early-init.el

The Modus themes can now be loaded through the early-init.el file. The idea is to avoid the flash of light that occurs under certain conditions during startup.

This feature is the result of several changes to helper functions, especially those contributing to the modus-themes-generate-palette function that Modus derivatives may be relying on.

Thanks to Steven Allen for an intermediate refinement in pull request 194 and to Mike Olson for another relevant tweak in pull request 199:

• https://github.com/protesilaos/modus-themes/pull/194
• https://github.com/protesilaos/modus-themes/pull/199

Steven’s contribution no longer exists in the code base due to other changes I made, but was still useful at the time.

Both changes are small, meaning that their authors do not need to assign copyright to the Free Software Foundation.

Also thanks to Jacod “Jake” Gordon for reminding me to apply one of the new functions to the org-habit faces. This was done in issue 197: https://github.com/protesilaos/modus-themes/issues/197.

The underline for widget fields has the correct colour

Relevant faces use the palette entry for border (invoke the command modus-themes-preview-colors or modus-themes-preview-colors-current to view the entries in a theme’s palette).

A popular package that makes use of widget.el widgets is notmuch.

Thanks to ukiran03 for the contribution, which was done in pull request 193: https://github.com/protesilaos/modus-themes/pull/193. The change is small, meaning that ukiran03 does not need to assign copyright to the Free Software Foundation.

A palette can now have a bg-popup entry

This gives users and derivative themes the option to pick a suitable value for popup interfaces, such as those of the company and corfu packages.

Thanks to aikrahguzar for making this suggestion in issue 70 of my ef-themes repository (the ef-themes are built on top of the modus-themes since Modus version 5.0.0, Ef version 2.0.0): https://github.com/protesilaos/ef-themes/issues/70.

Support for faces or packages

• lin by Protesilaos.
• pulsar by Protesilaos.
• institution-calendar by Protesilaos.
• markdown-ts-mode by Rahul Martim Juliato and Stéphane Marks.
• trust-manager by Eshel Yaron.
• typst-ts-mode by Ziqi Yang. Thanks to Pranshu Sharma for suggesting its inclusion in issue 208: https://github.com/protesilaos/modus-themes/issues/208.
• new elfeed faces since the maintenance of the project was assumed by Daniel Mendler, Karthik Chikmagalur, and Ihor Radchenko. To this end, thanks to Steven Allen for pull request 217 that added the elfeed-show-* faces: https://github.com/protesilaos/modus-themes/pull/217

Internal refinements to the modus-themes-with-colors macro

It now correctly handles the order of default palette colours and user-defined palette overrides. Thanks to JD Smith for the contribution in pull request 191: https://github.com/protesilaos/modus-themes/pull/191.

The change is small, meaning that JD does not need to assign copyright to the Free Software Foundation.

The multiple-cursors are fine even when a bar is used

When the cursor-type is configured to be a bar, the fake cursors produced by the multiple-cursors package will still look right. Thanks to Elias Gabriel Perez for the change to the mc/cursor-bar-face in pull request 213: https://github.com/protesilaos/modus-themes/pull/213.

The blink-matching-paren-offscreen is the same as show-paren-match

This is for thematic consistency. Thanks to Troy Brown for suggesting this change in issue 209: https://github.com/protesilaos/modus-themes/issues/209.

Get vc-annotate look right

The built-in vc-annotate command relies on a user option to read color values. We cannot handle this nicely at the theme level. Users need to write their own configuration like this:

(defun my-modus-vc-annotate (&rest _)
  (modus-themes-with-colors
    (setq vc-annotate-background-mode nil)
    (setq vc-annotate-very-old-color fg-dim)
    (setq vc-annotate-color-map
          `(( 20. . ,red)
            ( 40. . ,red-cooler)
            ( 60. . ,red-warmer)
            ( 80. . ,yellow-warmer)
            (100. . ,yellow)
            (120. . ,yellow-cooler)
            (140. . ,green-warmer)
            (160. . ,green)
            (180. . ,green-cooler)
            (200. . ,cyan-cooler)
            (220. . ,cyan-warmer)
            (240. . ,cyan)
            (260. . ,blue-warmer)
            (280. . ,blue)
            (300. . ,blue-cooler)
            (320. . ,blue-intense)
            (340. . ,magenta-cooler)
            (360. . ,fg-dim)))))

(with-eval-after-load 'vc-annotate
  (my-modus-vc-annotate)
  (add-hook 'enable-theme-functions #'my-modus-vc-annotate))

[ The above code is relevant as of this writing. Though remember that I do not keep older publications up-to-date. The only source of truth is the manual of the Modus themes. ]

Two old user options are no longer needed

The user options modus-themes-completions and modus-themes-prompts are obsolete. They used to be relevant before the introduction of palette overrides.

Rewrote large parts of the manual

I did it for clarity, but also to remove notes that were specific to older versions of Emacs.

Many new ERT tests for the project

I have written many tests. They do not cover every single function, though the plan is to do that eventually. These tests are important to ensure that Modus is a solid platform for making derivative themes.

Much of this was done live: https://protesilaos.com/codelog/2026-04-10-emacs-spontaneous-live-modus-themes/.

Thanks to Benjamin Kästner for a couple of tweaks to a relevant macro in the tests’ file. This was done in pull request 212, with further changes by me: https://github.com/protesilaos/modus-themes/pull/212.

Links to projects related to Modus

In the README.md I now mention projects that are related to the Modus themes, such as derivative Emacs themes, but also ports for other editors.

There is also a link to my modus-themes-exporter package, which I developed during a live stream:

• https://github.com/protesilaos/modus-themes-exporter
• https://protesilaos.com/codelog/2026-04-13-emacs-live-develop-modus-themes-exporter-package/

Git commits

git shortlog 5.2.0..5.3.0 --summary --numbered
    123	Protesilaos
     2	Benjamin Kästner
     2	Steven Allen
     1	Elias Gabriel Perez
     1	JD Smith
     1	Mike Olson
     1	ukiran03

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

Below are the release notes.

Version 2.2.0 on 2026-06-21

This version contains two new themes and several stylistic refinements to existing items in the collection.

Enjoy ef-arcadia and ef-atlantis themes

ef-arcadia is a light theme with a green, humid feel. ef-atlantis is a dark theme with aquatic colours.

Improved style for company and corfu popups

I have revised the colour that each theme applies to the popup background. It should now be more consistent with all other elements on display.

Thanks to aikrahguzar for suggesting a review in issue 70: https://github.com/protesilaos/ef-themes/issues/70.

The current line highlight for completions is easier to spot

This is the background of the selected candidate in the minibuffer while using the vertico package (among other similar interfaces). The colours I am now using are more consistent with their context and also work better as part of a popup completion interface, as noted above.

Palette refinements for several themes

I have made subtle changes to a few colour values. These are fine details. The overarching goal is to be consistent throughout.

Because of this, it is difficult for me to test the relevant values. Each Doric theme defines entries in its palette like fg-red and bg-blue. So I decided to write a small snippet that shows text which uses those colours in context.

The idea is to create faces that get the appropriate :foreground and :background attributes with their proper values. Then write text in a buffer that displays each face.

(defconst test-doric-accents
  '( fg-red fg-green fg-yellow fg-blue fg-magenta fg-cyan
     bg-red bg-green bg-yellow bg-blue bg-magenta bg-cyan))

(dolist (accent test-doric-accents)
  (custom-declare-face
   (intern (format "test-doric-%s" accent))
   nil
   "Test."
   :group 'doric-themes))

(defun test-doric-set-accent-faces ()
  (doric-themes-with-colors
    (let* ((predicate (lambda (symbol) (string-prefix-p "bg" (symbol-name symbol))))
           (foregrounds (seq-remove predicate test-doric-accents))
           (backgrounds (seq-filter predicate test-doric-accents))
           (foreground-faces (mapcar
                              (lambda (accent)
                                `(,(intern (format "test-doric-%s" accent))
                                  ((t :foreground ,(symbol-value accent)))))
                              foregrounds))
           (background-faces (mapcar
                              (lambda (accent)
                                `(,(intern (format "test-doric-%s" accent))
                                  ((t :background ,(symbol-value accent) :foreground ,fg-main))))
                              backgrounds)))
      (apply #'custom-set-faces (append foreground-faces background-faces)))))

(add-hook 'doric-themes-after-load-theme-hook #'test-doric-set-accent-faces)

(defun test-doric-show-accents ()
  (interactive)
  (let ((buffer (get-buffer-create "*test-doric-themes-accents*")))
    (with-current-buffer buffer
      (erase-buffer)
      (dolist (accent test-doric-accents)
        ;; Pangram from my `show-font' package...
        (let* ((text "Protesilaos may find zesty owls and quiet jays vexing the black cat")
               (styled (propertize text 'face (intern (format "test-doric-%s" accent)))))
          (insert (format "%s\n" styled)))))
    (display-buffer buffer)))

Reload the theme for changes to take effect.

And, yes, I had the motivation to write this because I am developing new themes.

Doric themes sources

• 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.

A flat Dired listing

For a while now I have been using my own command to create a Dired buffer from the current directory (which can always be updated on demand with M-x cd). It is prot-dired-search-flat-list. Here is the code:

(defvar prot-dired-regexp-history nil
  "Minibuffer history of `prot-dired-regexp-prompt'.")

(defun prot-dired-regexp-prompt ()
  (let ((default (car prot-dired-regexp-history)))
    (read-regexp
     (format-prompt "Files matching REGEXP" default)
     default 'prot-dired-regexp-history)))

(defun prot-dired--get-files (regexp)
  "Return files matching REGEXP, recursively from `default-directory'."
  (directory-files-recursively default-directory regexp nil))

;;;###autoload
(defun prot-dired-search-flat-list (regexp)
  "Return a Dired buffer for files matching REGEXP.
Perform the search recursively from the current directory."
  (interactive (list (prot-dired-regexp-prompt)))
  (if-let* ((files (prot-dired--get-files regexp))
            (relative-paths (mapcar #'file-relative-name files)))
      (dired (cons (format "prot-flat-dired for `%s'" regexp) relative-paths))
    (error "No files matching `%s'" regexp)))

I could modify prot-dired-search-flat-list to also prompt for a directory, though I optimise for the common workflow of operating from where I am (and I generally do not like overloading the C-u with special cases that I will never remember—a new command with a name I can search for is better).

Flat listing limited to last modified since DAYS

Yesterday I had the need to browse a massive directory, but only wanted to get a couple of files out of it. I realised that I had to filter my last modified, so I extended my above use-case with the new command prot-dired-search-flat-list-since-days. Here is what I came up with:

(defvar prot-dired-days-prompt-history nil
  "Minibuffer history for `prot-dired-days-prompt'.")

(defun prot-dired-days-prompt ()
  "Prompt for days and return them as a number."
  (let* ((first (car prot-dired-days-prompt-history))
         (default (when (stringp first)
                    (string-to-number first))))
    (read-number "Number of days: " default 'prot-dired-days-prompt-history)))

(defun prot-dired--get-last-modified (files days)
  "Return list of FILES last modified since DAYS."
  (seq-filter
   (lambda (file)
     (and-let* ((attributes (file-attributes file))
                (last-modified (nth 5 attributes))
                (last-modified-seconds (time-to-seconds last-modified))
                (current-time (current-time))
                (current-time-seconds (time-to-seconds current-time))
                (delta-seconds (* days 24 60 60))
                (oldest-seconds (- current-time-seconds delta-seconds))
                (_ (>= last-modified-seconds oldest-seconds)))))
   files))

;;;###autoload
(defun prot-dired-search-flat-list-since-days (regexp days)
  "Return Dired buffer with files matching REGEXP up to DAYS since last modification.
Perform the search recursively from the current directory."
  (interactive
   (list
    (prot-dired-regexp-prompt)
    (prot-dired-days-prompt)))
  (if-let* ((files (prot-dired--get-files regexp)))
      (if-let* ((files-filtered (prot-dired--get-last-modified files days))
                (relative-paths (mapcar #'file-relative-name files-filtered)))
          (dired (cons (format "prot-flat-dired since %d days for `%s'" days regexp) relative-paths))
        (error "No files last modified within the last %d days" days))
    (error "No files matching `%s'" regexp)))

Note that I always design my minibuffer prompts to have their own history, because then I only get relevant entries when I press M-p (previous-history-element) and M-n (next-history-element) at the prompt (and the built-in savehist-mode takes care to persist those).

Everything is part of my Emacs configuration: https://protesilaos.com/emacs/dotemacs. I will not be updating this article, so make sure to check for any further refinements there.

I will join Sacha’s live stream this Thursday to talk about underappreciated features that are built into Emacs. There are a lot of nice things that are available out-of-the-box (plus many packages that build on top of them). I am looking forward to it!

The video will be recorded for future reference.

Tomorrow, the 28th of May 2026 at 17:30 Europe/Athens time, I will join Sacha Chua’s live stream.

We will talk about the Emacs blog carnival topic for this month, which is “May I recommend”. The video will be recorded for future reference.

I already have some ideas and am looking forward to our chat!

• ef-arcadia is a light theme with a verdant, humid aesthetic.
• ef-atlantis is a dark theme with an aquatic feel.

Both deliver the familiar colourfulness and good legibility of the ef-themes.

Always click to enlarge the image for best results.

ef-arcadia

ef-atlantis

Coming in version 2.2.0 (next stable release)

The character of each theme is well defined. I may still make some refinements.

Remember that since version 2.0.0, the ef-themes are built on top of my modus-themes. This means that they are highly customisable, support a wide range of packages and face groups, and are extensively tested down to the finest details.

Enjoy!

The ef-themes are a collection of light and dark themes for GNU Emacs that provide colourful (“pretty”) yet legible options for users who want something with a bit more flair than the modus-themes (also designed by me).

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

Denote is based on the idea that files should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the contents are about, without reference to any other metadata. Denote basically streamlines the creation of such files or file names while providing facilities to link between them (where those files are editable).

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a constistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

Below are the release notes.

Version 4.2.0 on 2026-05-20

This version brings several improvements to the core denote package as well as all the Denote extensions I maintain. The core package is stable, its feature set is rich, and the wider ecosystem of extensions is growing.

Most of the changes documented herein are of interest to experienced users who may be looking for ways to refine their workflow. I recommend that new users start with the basics, as I explained them in the original video demonstration of Denote or as they are documented in the manual’s section for newcomers:

• Webpage: https://protesilaos.com/emacs/denote#h:c54bedb4-5377-4dbd-853c-5870ace6eb33.
• Info manual: With the latest denote package installed, evaluate (info "(denote) Getting started with Denote").

Remember that the release notes are true only at the time of publication. The single source of truth is the official manual.

Core Denote

Overview of the new features

• The command denote-dired-focus will filter the results of an existing denote-dired buffer. Use this to narrow down the results.

• In Org files, the denote: link type can now be previewed using the built-in org-link-preview command, starting with Org version 9.8.0.

• The command denote-link-or-create-with-command extends the existing convenience functions of the “do or create note” kind.

• The denote-file-prompt uses completion metadata to sort by most recently accessed, group by directory or file extension, and cover packages that display cosmetic icons alongside completion candidates.

• Denote now enforces a controlled vocabulary for keywords when denote-infer-keywords is set to nil, such that only the denote-known-keywords are provided as an option at the relevant prompts.

• The mechanism for integrating Denote with org-capture now supports prompting for an signature via denote-org-capture-with-prompts (the signature is an optional, free-form component of the Denote file-naming scheme).

• Several packages that extend Denote are documented in the manual. If you have a package for Denote, let me know and I will write a section about it.

Focus a denote-dired buffer with denote-dired-focus

The command denote-dired produces a Dired listing of file names that match the given regular expressions. Users can benefit from the Denote file-naming scheme to, for example, include all files that have the keyword _emacs. In the resulting Dired buffer, the new command denote-dired-focus can then be invoked to further narrow down the results, such as to only show files that have 2026 in their file (with default settings, the date is part of the Denote identifier).

I implemented this feature in response to issue 693 by 82Kang: https://github.com/protesilaos/denote/issues/693.

Improvements to the file prompt

Various Denote commands prompt for a file name: for instance, denote-link asks which file to link to. This file prompt is now augmented with completion metadata that transform how files look and how the information is organised.

Before, the prompt presented full file names like:

20220610T043241--initial-thoughts-on-the-zettelkasten-method__notetaking.org
20220610T062201--define-custom-org-hyperlink-type__denote_emacs_package.md
20220610T162327--on-hierarchy-and-taxis__notetaking_philosophy.txt

Those same file names are now transformed to look like this:

2022-06-10  initial-thoughts-on-the-zettelkasten-method  notetaking
2022-06-10  define-custom-org-hyperlink-type  denote_emacs_package
2022-06-10  on-hierarchy-and-taxis  notetaking_philosophy

The files will be grouped by file extension or directory (if they are in a subdirectory of the denote-directory). Furthermore, they will be sorted by most recently accessed.

The underlying file names are still available except that their presentation is modified. This means that input at the minibuffer prompt will still match everything they contain.

This completion metadata extends to the packages all-the-icons and nerd-icons, which are now instructed to add the correct file icons to the completion candidates: an Org file will have the unicorn icon beside it, for example.

Users who do not like the new style can revert to the plain presentation by setting denote-file-prompt-extra-metadata to nil.

Advanced users who wish to set up the completion-category-overrides may target the denote-file completion category or, anyhow, modify the denote-file-prompt-extra-metadata.

Link to a file or create a new note using a specific command

Denote provides many “convenience wrapper” commands that do something quickly which can also be achieved with minimal configuration. For example, the denote command may be modified to also prompt for a file type and so the denote-type command is like denote with the addition of the file type prompt. Users can look at the source code of denote-type to write their own small variations (the manual provides several examples as well).

The denote-open-or-create-with-command may then use those to implement its specified behaviour of “open an existing file or create it using a convenience wrapper command”.

Same principle for the new denote-link-or-create-with-command: it makes possible the workflow of “link to an existing file or create a new note with the given command”.

Convenience wrappers are listed in the value of the user option denote-commands-for-new-notes.

Thanks to Matthew Batson for building on top of existing functionality to contribute denote-link-or-create-with-command in pull request 674: https://github.com/protesilaos/denote/pull/674. Matthew has assigned copyright to the Free Software Foundation.

Preview denote: links in Org files

Starting with Org version 9.8.0 custom link types such as denote: can implement their own preview mechanism. In practice, this means that denote: links pointing to image files will now work as expected with org-link-preview (remember that the Denote file-naming scheme can be applied to any file and is in no way specific to note-taking—I use it for documents and videos, for example).

Thanks to Samuel W. Flint for the original contribution in pull request 683: https://github.com/protesilaos/denote/pull/683, with further changes by me. The original contribution is small, meaning that Samuel does not need to assign copyright to the Free Software Foundation.

Signature support in Org capture

The denote-org-capture-with-prompts function now supports the signature file name component as an additional parameter. This function is meant to be used in tandem with the org-capture mechanism, as shown in the manual.

Thanks to Tobias Lidman-Strauss for the contribution in merge request 2 on the GitLab mirror: https://gitlab.com/protesilaos/denote/-/merge_requests/2. The change is small, meaning that Tobias does not need to assign copyright to the Free Software Foundation.

The denote-fontify-links-mode is only relevant for .txt files

The denote: links are automatically highlighted as links in Org and Markdown bufers. Users who prefer to write notes in plain .txt files must enable the denote-fontify-links-mode to get the same effect.

I have revised denote-fontify-links-mode to only work with .txt as its other users were not necessary. In the process, I have deprecated the denote-fontify-links-mode-maybe function: just use the denote-fonftify-links-mode.

The keys RET and C-c C-o open the link (same keys used by Org and Markdown modes).

Growing ecosystem of Denote packages

In the Denote manual I mention packages that build on top of Denote. There is one section for each package. The manual now includes the following:

• denote-agenda (by Samuel W. Flint): Use Denote notes as Org agenda files.
• denote-journal-capture (by Samuel W. Flint): Enhanced journaling workflows.
• denote-lint (Peter Smith): Checks for inconsistencies in Denote file names and front matter.
• denote-project-notes (by Samuel W. Flint): Integrate Denote with Emacs’ built-in project support.
• denote-regexp (by Samuel W. Flint): Search and link notes using regular expressions.
• denote-review (by Matto Fransen): A package for reviewing notes over time.
• denote-sections (by Samuel W. Flint): Manage sections within Denote notes.
• denote-wordcloud (by Alexander Kuzmin): Generate word clouds from Denote notes.

Miscellaneous

• The command denote-dired (alias denote-sort-dired) is refactored to work as intended in all cases. Thanks to kilesduli for the contribution in pull request 666: https://github.com/protesilaos/denote/pull/666. Further changes by me, including the option to maintain many separate denote-dired buffers, which I did in response to issue 693 by 82Kang: https://github.com/protesilaos/denote/issues/693.

• I have revised the denote-grep mechanism and all of its ancillary functions and variables are revised in the interest of consistency and maintainability. Thanks to gnuhack for contributing a macro that was meant to streamline some commands. This was done in pull request 697: https://github.com/protesilaos/denote/pull/697. I eventually changed lots of things so that the macro was not relevant anymore, though mine was a change with a wider scope.

• The Org link storage mechanism (denote-link-ol-store) now works correctly within org-capture buffers, allowing for more flexible linking workflows.

• Following non-Denote Markdown links no longer result in an error under certain circumstances. Thanks to bplubell for the contribution in pull request 685: https://github.com/protesilaos/denote/pull/685. The change is small, meaning that its author does not need to assign copyright to the Free Software Foundation.

• Retrieving front matter is now more reliable, even when the buffer is unsaved. Thanks to kilesduli for the contribution in pull request 672: https://github.com/protesilaos/denote/pull/672. Also thanks to Jean-Philippe Gagné Guay for reviewing the change and for reporting a problem with an earlier version of the code in issue 670: https://github.com/protesilaos/denote/issues/670. Further changes by me.

• The various Denote rename commands that affect the front matter in files no longer change existing spacing. I did this to address the comment posted by Morten Kjeldgaard in issue 703: https://github.com/protesilaos/denote/issues/703.

• Updated the documentation to explain how to automatically encrypt new notes when using a custom file type.

• Refined the internal helper functions for directory management and identifier validation.

• Thanks to nescias for fixing three typos in the manual. This was sent to me as a patch, which I installed as commit c772378.

Changes to the extensions of Denote I maintain

This is about packages I maintain. Some of them were originally part of the denote.git repository, but I moved them out into their own packages to make everything easier to reason about.

consult-denote version 0.5.0

• Package name (GNU ELPA): consult-denote
• Official manual: https://protesilaos.com/emacs/consult-denote
• Change log: https://protesilaos.com/emacs/consult-denote-changelog
• Git repository: https://github.com/protesilaos/consult-denote

• Backronym: Consult-Orchestrated Navigation and Selection of Unambiguous Targets…denote.

• References to the long-obsolete “denote-silo-extras-” prefix are replaced by “denote-silo-”. Thanks to IT Ascalium for the contribution in pull request 20: https://github.com/protesilaos/consult-denote/pull/20. The change is small, so its author does not need to assign copyright to the Free Software Foundation.

• The consult-denote-file-prompt correctly handles relative file paths when denote-directory is set to a list of directories. This is what the underlying denote-file-prompt does (which I mentioned above about its metadata). Thanks to Kai von Fintel for the contribution in pull request 24: https://github.com/protesilaos/consult-denote/pull/24. The change does not require copyright assignment.

denote-merge version 0.1.0

• Git repository: https://github.com/protesilaos/denote-merge
• Official manual: https://protesilaos.com/emacs/denote-merge
• Backronym: Denote… Merging Eventually Reformats the Given Entries.

This is an optional extension to the denote package. It provides commands and relevant user options to streamline the work of merging contents from one Denote file to another. This is for users who periodically review their notes to add, remove, or otherwise consolidate their accumulated knowledge.

denote-journal version 0.3.0

• Package name (GNU ELPA): denote-journal
• Official manual: https://protesilaos.com/emacs/denote-journal
• Git repository: https://github.com/protesilaos/denote-journal

• Backronym: Denote… Journaling Obviously Utilises Reasonableness Notwithstanding Affectionate Longing.

• The user option denote-journal-keyword now supports a nil value, allowing users to create journal entries without a specific keyword. Thanks to nescias for sending me the patch via email, which I installed as commit d4cc501 in denote-journal.git. The change does not require copyright assignment.

• Fixed an issue about how the function denote-directory-files was used. Thanks to Donald Brady for reporting the bug in issue 656 on the main Denote repository and to kamchy for confirming the problem: https://github.com/protesilaos/denote/issues/656. The approach was utlimately revised in denote.git courtesy of a change by Jean-Philippe Gagné Guay in pull request 661: https://github.com/protesilaos/denote/pull/661.

denote-markdown version 0.3.0

• Package name (GNU ELPA): denote-markdown
• Official manual: https://protesilaos.com/emacs/denote-markdown
• Git repository: https://github.com/protesilaos/denote-markdown

• Backronyms: Denote… Markdown’s Ambitious Reimplimentations Knowingly Dilute Obvious Widespread Norms; Denote… Markup Agnosticism Requires Knowhow to Do Only What’s Necessary.

• The package defines a markdown-obsidian file type which can be used by relevant note-creating commands, such as denote or the convenience wrapper denote-type. This file type is updated to be more robust, in accordance with some changes in core Denote (I am not even documenting those, as they are not intended for users).

denote-org version 0.3.0

• Package name (GNU ELPA): denote-org
• Official manual: https://protesilaos.com/emacs/denote-org
• Git repository: https://github.com/protesilaos/denote-org

• Backronym: Denote… Ordinarily Restricts Gyrations.

• The command denote-org-link-to-heading now supports linking to the current file when called with a prefix argument. This way, a file can have links between its headings. Thanks to Tonus for pointing out that it was impossible to create a link inside the current file. This was done in issue 17: https://github.com/protesilaos/denote-org/issues/17.

• A helper function for retrieving the backlinks of a heading is updated to return full file paths. Thanks to Vedang Manerikar for the contribution in pull request 20: https://github.com/protesilaos/denote-org/pull/20. Vedang has assigned copyright to the Free Software Foundation.

• Another helper function is updated to conform with changes to core Denote with regard to how the denote-link-description-format is handled. Thanks to Jung Han for reporting the bug in issue 21: https://github.com/protesilaos/denote-org/issues/21.

denote-silo version 0.3.0

• Package name (GNU ELPA): denote-silo
• Official manual: https://protesilaos.com/emacs/denote-silo
• Git repository: https://github.com/protesilaos/denote-silo
• Backronym: Denote… Silos Insulate Localised Objects.

The minibuffer prompt for silo directories uses the corrent completion category (consistent with what I mentioned above about completion metadata). Thanks to Wilf-bog for reporting an error with the completion prompt in issue 1: https://github.com/protesilaos/denote-silo/issues/1.

denote-sequence version 0.3.0

• Package name (GNU ELPA): denote-sequence
• Official manual: https://protesilaos.com/emacs/denote-sequence
• Git repository: https://github.com/protesilaos/denote-sequence
• Backronym: Denote… Sequences Efficiently Queue Unsorted Entries Notwithstanding Curation Efforts.

This package deserved its own release notes, as I did a lot of work on it. But as this file is already long, I will focus on the essentials:

• The denote-sequence-scheme used to support a numeric and alphanumeric option. There now is a third one called alphanumeric-delimited. It combines features from the other two and may be better suited for especially long/intricate sequences.

• The denote-sequence-reparent command now works recursively to produce the desired consequences to all descendants of a given sequence note. Thanks to Peter Prevos for the contribution in pull request 13, which further changes by me: https://github.com/protesilaos/denote-sequence/pull/13.

• The command denote-sequence-view-hierarchy produces a bespoke buffer with all the sequence notes that form a hierarchy. The buffer displays file titles, the concomitant sequence, and file keywords. Each level of depth is expressed by a number of spaces, controlled by the user option denote-sequence-hierarchy-indentation. In the hierarchy buffer, there are commands that move to the next/previous item, or forward/backward at the same level of depth. RET opens the file at point, TAB folds/unfolds the tree. The user option denote-sequence-hierarchy-move-and-open controls whether motion commands should automatically open the file, which by default happens in the other window (users who modify the variable denote-open-link-function will get the specified behaviour in this context as well). The denote-sequence-view-hierarchy can be called with one or two prefix arguments to limit to a given sequence prefix and/or level of depth (something that denote-sequence-dired also supports). In short, this is a way to visualise your sequence notes in a buffer that has a different presentation than Dired.

• Thanks to alan-w-255 for renaming and refining a prompt that is also used in the hierarchy feature. This was done in pull request 15: https://github.com/protesilaos/denote-sequence/pull/15. The change is small, meaning that its author does not need to assign copyright to the Free Software Foundation. Further refinements by me.

• Thanks to Nicolas Semrau for binding q to quit-window in the denote-sequence-hierarchy-mode-map. This was done in pull request 20: https://github.com/protesilaos/denote-sequence/pull/20. The change is small, meaning that Nicolas does not need to assign copyright to the Free Software Foundation.

• The denote-sequence-file-prompt-extra-metadata is the functional equivalent of the aforementioned denote-file-prompt-extra-metadata.

• Thanks to liyingzhi for pointing out an inaccurate comment in the docstring of denote-sequence-scheme. This was done in issue 18: https://github.com/protesilaos/denote-sequence/issues/18.

• The denote-sequence-dired is updated to align with the modalities of denote-dired, as noted above. Thanks to juh for reminding me about the need for changes in issue 14: https://github.com/protesilaos/denote-sequence/issues/14.

• Thanks to Stefan Monnier for pointing out a stylistic mistake in an older version of denote-sequence-dired. This was done on the emacs-devel mailing list: https://lists.gnu.org/archive/html/emacs-devel/2025-11/msg01119.html. Also thanks to Stefan for telling me about some other compiler warnings: https://lists.gnu.org/archive/html/emacs-devel/2025-11/msg01119.html.

Git commits

~/Git/Projects/denote $ git shortlog 4.1.0..4.2.0 --summary --numbered
   184	Protesilaos
     4	duli
     3	Jean-Philippe Gagné Guay
     3	Matthew Batson
     2	alvmts
     2	gnuhack
     1	Alvin Hsu
     1	Matto Fransen
     1	Samuel W. Flint
     1	Tobias Lidman-Strauss
     1	bplubell
     1	gvalson
     1	nescias

We started with a review of the latest changes to the ffs package that Amin has been developing. We had looked into it before and wanted to check on its current state.

Amin then asked me about the display-buffer-alist, which I had mentioned before. To me, this is the single most important variable for making Emacs feel more like your own. The reason is that it allows you to control the placement of buffers to match your expectations. I demonstrated some of the main ideas.

Another nice little feature is the built-in isearch. I explained how it is especially helpful while recording keyboard macros. Though it is nice to use in general. One tweak for it is to display a counter with its matches. Another is to change how it treats spaces, so that it can match any character in-between. This is not as flexible as, say, consult-line (from the consult package) when combined with vertico and orderless. Though it still has its uses.

[ I have lots of little extras for isearch, but those should be good for most users. ]

Amin told me about rediscovering the value of Org in the context of statically generating his website. He showed me the custom Org HTML export backend he has been working on. Org has so many nice features which can be used independent of each other. In this light, we also discussed the diary compared to the Org agenda.

Find all of Amin’s publications on his website: https://kelar.org/~bandali/.

Amin asked me to record the meeting and then publish it, which I happily agreed to. You can watch it on Amin’s website: https://kelar.org/~bandali/gnu/emacs/ffs-code-review-prot.html.

[ NOTE: I normally do not share anything about my meetings with people. Not who they are nor what we talk about. ]

Thanks to Amin for making this happen! I am looking forward to new developments.

By the way, I learnt about the function x-export-frames from a mention in Amin’s ffs package, which led me to write buffer-to-pdf: https://github.com/protesilaos/buffer-to-pdf.

On the 14th of May we will meet with Sacha and Philip to talk about the upcoming Emacs 31 and other developments heading into Emacs 32. Philip is a contributor to core Emacs and the main driver behind the new newcomers-presets theme, among others. We will cover themes related to the newcomer experience.

I am looking forward to it!

As I understand, you’re using the regular keybindings in emacs. I’m trying to transition away from the vim way of editing text and was wondering if you’re using a more ergonomic approach for your text editing needs. I remember you were using some ergo split keyboards for that?

Indeed, I have a split mechanical keyboard (a gift from a person who identifies as “Andreas”). It is the Iris revision 8 by Keebio. I also have a regular full-sized keyboard (a gift from Arialdo Martini), which is the Keychron K5.

[ Keyboard-related articles of mine: https://protesilaos.com/keeb/. ]

The split keyboard is nice, though it is not a magical solution. Even with a regular form factor keyboard, I can work with the standard Emacs keys without any problem. What helps me the most is to configure one-shot modifiers. This means that I can tap (press once, then release) a modifier key, then tap a regular key to register it as a modifier+key event. For example, C-x is this: tap Ctrl, then tap x. Shift tapping is especially nice for prose, by the way, and eases the pressure on the otherwise weak pinky. The time window for registering a one-shot modifier is configurable.

The other useful tweak for a regular keyboard is to rearrange the layout of the modifiers. I prefer this order:

Super Alt Ctrl Space Ctrl Alt Super

[ If there is a Menu key, move it to the right corner and consider assigning it to the Compose key if you are on Linux. ]

Now Ctrl is under the thumb, which is especially nice for Emacs. Alt and Super can be swapped, if you use Super more heavily (e.g. with a tiling window manager). But the important part is to keep Ctrl close to the Space key.

Whatever you do though, remember to use both sets of modifiers. For example, C-x involves the right hand for Ctrl and the left hand for x. C-p needs the left hand for Ctrl and the right hand for p. This way you distribute the burden so no one side is overworked (and, of course, you take regular breaks from typing altogether).

Lots of Emacs users will rebind Caps Lock to Ctrl. While this is fine in its own right, it tends to embed bad habits, such as with using only the left hand to register the very common C-a, C-e, C-d, C-f, C-s, C-r, C-w, C-g, C-z, C-x, C-c, C-v. Exclusive left-handed use involves awkward twisting of the muscles which will probably hurt you over time. Plus, the left pinky is forced to press and hold a key while being stretched—looks bad. Again, distribute the load.

The final part that makes everything easier is to configure a “layer” key. When you press and hold this key, other keys register a different input than normal. For example, Caps Lock can be the layer key, which then makes h, j, k, l act as arrow keys. Same idea for mapping Home, PgDn, PgUp, End someplace that makes sense (mine are on y, u, i, o). I prefer to have Space as that layer key: it only is a layer when I press and hold it, otherwise it performs the ordinary function of the Space key.

It is okay to press and hold Space because you do it with your relatively strong thumbs. Better have it this way than pressing and holding with the pinkies.

All this can be achieved with software such as kanata. A custom keyboard with QMK firmware can get the same configuration embedded directly in the keyboard (so it works without any special program running on the computer). Kanata will be the cheaper solution and is probably better overall if you consider that it can apply to a laptop’s keyboard.

A mistake in all this is to think that an expensive keyboard is inherently more ergonomic. If you keep curling, overextending, or anyhow stressing your muscles the injuries will occur regardless. A new keyboard can help if you use it as an opportunity to retrain your muscle memory.

Custom keyboards have potential advantages in terms of comfort because you can change the switches and keycaps that they use. For example, you can pick a lighter or heavier switch to match your typing technique. Then you can combine it with a shallower or steeper keycap profile to get the most out of that setup. There is no right or wrong here. It is a matter of optimising on top of the strong fundamentals that I outlined above.

As for evil-mode in Emacs, I think it is a good solution overall. You do, however, need to install the evil-collection package and probably also configure lots of other key bindings to get exactly what you want. There are other packages that give you modal editing, though I have only ever used evil-mode in earnest: it is fine.

That granted, I find that I do not like modal editing in general. It is especially inconvenient for me when I write at length (which I do a lot) because I tend to produce a wall of text in one go. Having a modal interface gives me no advantage in this common scenario. I also doubt it ever gave me the edge while programming. The bottleneck is how quickly and clearly I can think, not how fast I can edit lines of text (though, yes, Vim’s paradigm is powerful).

Consider then the overall comfort of your setup. Both in terms of the ergonomics of hardware but also how much effort it takes to maintain your Emacs configuration. The standard approach to key bindings gives you something that “just works” with practically every package you install. It may feel awkward in the beginning if you are coming from the Vim keys, but will be the most robust solution long-term from the perspective of maintainability.

In this short video I demonstrate my new package for Emacs. It is called buffer-to-pdf. The idea is to save your current buffer to a PDF, while preserving how it looks. This means that your font size, theme, and other visual effects are preserved and written to the PDF. buffer-to-pdf is not meant to be a replacement for elaborate export methods: consider it a quick yet effective way to get a “screen capture” of your Emacs that you can then share as a document. I believe this will be especially useful for academics or people who need to distribute presentation notes on a regular basis. The package is available here: https://github.com/protesilaos/buffer-to-pdf.

UPDATE 2026-05-01 08:24 +0300: Added a missing :config to the bookmark block.

UPDATE 2026-05-02 22:33 +0300: Replaced duplicate variable-pitch with the intended fixed-pitch.

;;; Sensible defaults that are not too intrusive and focus on common use-cases.  By Protesilaos on 2026-04-30.

;; These are not all of my favourite options.  I am not even including
;; any of my packages.  They are just some basics that I consider
;; useful, given what I have learnt from my exchange with other people
;; of all skill levels.


;; Persist all customisations in a separate file called "custom.el".
;; It is in the same directory as the "init.el".
;;
;; Without the `custom-file', Emacs writes directly to the "init.el",
;; which can be confusing.
(setq custom-file (locate-user-emacs-file "custom.el"))
(load custom-file :no-error-if-file-is-missing)

(use-package package
  :ensure nil
  :config
  ;; I am not using `add-to-list' here because the default "gnu" is
  ;; confusing to people, given that "elpa" is the better known name
  ;; for it.
  (setq package-archives
        '(("gnu-elpa" . "https://elpa.gnu.org/packages/")
          ("nongnu" . "https://elpa.nongnu.org/nongnu/")
          ("melpa" . "https://melpa.org/packages/")))
  ;; Prefer GNU ELPA but accept the reality of MELPA's utility to the
  ;; wider community.
  (setq package-archive-priorities
        '(("gnu-elpa" . 3)
          ("nongnu" . 2)
          ("melpa" . 1))))

;;;; General options
(use-package emacs
  :ensure nil
  :demand t
  :init
  (defun prot/keyboard-quit-dwim ()
    "Do-What-I-Mean behaviour for a general `keyboard-quit'.

The generic `keyboard-quit' does not do the expected thing when
the minibuffer is open.  Whereas we want it to close the
minibuffer, even without explicitly focusing it.

The DWIM behaviour of this command is as follows:

- When the region is active, disable it.
- When a minibuffer is open, but not focused, close the minibuffer.
- When the Completions buffer is selected, close it.
- In every other case use the regular `keyboard-quit'."
    (interactive)
    (cond
     ((region-active-p)
      (keyboard-quit))
     ((derived-mode-p 'completion-list-mode)
      (delete-completion-window))
     ((> (minibuffer-depth) 0)
      (abort-recursive-edit))
     (t
      (keyboard-quit))))
  :bind
  ("C-g" . prot/keyboard-quit-dwim)
  :config
  ;; Set your favourite font family and height here.  The :height is
  ;; 10x the point size you most commonly find on other applications.
  (set-face-attribute 'default nil :family "Aporetic Sans Mono" :height 160)
  ;; Set your favourite font for elements that are designed to always
  ;; be monospaced.  The height SHOULD BE a floating point, which is
  ;; interpreted as relative to the `default'.
  (set-face-attribute 'fixed-pitch nil :family "Aporetic Serif Mono" :height 1.0)
  ;; Same as above for proportionately spaced elements.  Make any
  ;; buffer proportionately spaced by enabling the `variable-pitch-mode'.
  ;;
  ;; [ NOTE: If you use the Modus themes or derivatives, set
  ;;   `modus-themes-mixed-fonts', load the theme for the option to
  ;;   take effect, and then enable `variable-pitch-mode':
  ;;   spacing-sensitive elements like Org tables and code blocks will
  ;;   remain monospaced. ]
  (set-face-attribute 'variable-pitch nil :family "Aporetic Sans" :height 1.0)

  ;; I have never seen a user say "no" to loading a theme they have
  ;; downloaded.  Technically, any Elisp file can run arbitrary code,
  ;; so this is not doing much on the security front.
  (setq custom-safe-themes t)
  (setq use-short-answers t)
  (setq read-answer-short t)
  (setq help-window-select t) ; also check `display-buffer-alist' below
  (setq help-window-keep-selected t) ; Emacs 29
  (setq find-library-include-other-files nil) ; Emacs 29
  (setq window-combination-resize t)
  (setq save-interprogram-paste-before-kill t)
  ;; Do not jump to the current line in `*occur*' buffers.  The reason
  ;; is that you are already on that line: you want to do `occur' to
  ;; get more than that (and, presumably, to do something with the
  ;; results such as to edit them with `occur-edit-mode').
  (setq list-matching-lines-jump-to-current-line nil)
  (setq completion-category-defaults nil))

;;;; Save minibuffer histories
(use-package savehist
  :ensure nil
  :config
  (savehist-mode 1))

;;;; Delete the selected text when inserting new text
(use-package delsel
  :ensure nil
  :config
  (delete-selection-mode 1))

;;;; Bookmarks
(use-package bookmark
  :ensure nil
  :config
  ;; Emacs 29 displays a bookmark icon on the fringe.  Many people
  ;; have asked me what that thing is.  I also think it is confusing.
  (setq bookmark-fringe-mark nil)
  ;; Write changes to the bookmark file as soon as 1 modification is
  ;; made (addition or deletion).  Otherwise Emacs will only save the
  ;; bookmarks when it closes, which may never happen properly
  ;; (e.g. power failure).
  (setq bookmark-save-flag 1))

;;;; Dired
(use-package dired
  :ensure nil
  :config
  ;; Most people I have talked to prefer a single Dired buffer.
  ;; Personally I like the many Dired buffers, but I understand why
  ;; this feels overwhelming.
  (setq dired-kill-when-opening-new-dired-buffer t)
  (setq dired-auto-revert-buffer #'dired-directory-changed-p) ; also see `dired-do-revert-buffer'
  (setq dired-clean-up-buffers-too t)
  (setq dired-clean-confirm-killing-deleted-buffers t)
  (setq dired-recursive-copies 'always)
  (setq dired-recursive-deletes 'always)
  (setq delete-by-moving-to-trash t)
  (setq dired-create-destination-dirs 'ask)
  (setq dired-create-destination-dirs-on-trailing-dirsep t) ; Emacs 29
  (setq wdired-create-parent-directories t))

;;;; Isearch
(use-package isearch
  :ensure nil
  :config
  ;; ;; Enable those to make "package install" match those words with
  ;; ;; anything in between.  I think this is the single best tweak I
  ;; ;; ever made.
  ;;
  ;; (setq search-whitespace-regexp ".*?")
  ;; (setq isearch-lax-whitespace t)
  ;; (setq isearch-regexp-lax-whitespace nil)
  (setq isearch-lazy-count t)
  (setq lazy-count-prefix-format "(%s/%s) ")
  (setq lazy-count-suffix-format nil))

;;;; Diff
(use-package diff
  :ensure
  :config
  ;; You cannot expect the syntax highlighting of themes to look
  ;; equally readabable against what typically are red and green
  ;; backgrounds.  This should be opt-in by default, not opt-out.
  (setq diff-font-lock-syntax nil))

;;;; Ediff
(use-package ediff
  :ensure nil
  :config
  ;; Ediff is virtually unusable without those.  Especially on tiling
  ;; window managers.  But even on a regular desktop environment it is
  ;; confusing and cumbersome to have the control panel in another
  ;; frame.
  (setq ediff-split-window-function 'split-window-horizontally)
  (setq ediff-window-setup-function 'ediff-setup-windows-plain))

;;;; SHR
(use-package shr
  :ensure nil
  :config
  ;; t is bad for accessibility and generally awkward for HTML email
  ;; (especially with dark themes).
  (setq shr-use-colors nil)
  ;; This option should not exist, given `variable-pitch-mode'.
  ;; Furthermore, its default value runs counter to almost everything
  ;; else in Emacs which just uses the `default' face.
  (setq shr-use-fonts nil))

;;;; Control the display of common ancillary windows

;; Always focus common ancillary windows.  Place them in a window
;; already occupied by their respective major mode or below the
;; current window.
(add-to-list 'display-buffer-alist
             '((or . ((derived-mode . occur-mode)
                      (derived-mode . grep-mode)
                      (derived-mode . Buffer-menu-mode)
                      (derived-mode . log-view-mode)
                      (derived-mode . help-mode)))
               (display-buffer-reuse-mode-window display-buffer-below-selected)
               (body-function . select-window)))

(add-to-list 'display-buffer-alist
             '("\\`\\*\\(Org \\(Select\\|Note\\)\\|Agenda Commands\\)\\*\\'" ; the `org-capture' key selection, `org-add-log-note', and agenda dispatcher
               (display-buffer-in-side-window)
               (dedicated . t)
               (side . bottom)
               (slot . 0)
               (window-parameters . ((mode-line-format . none)))))

(add-to-list 'display-buffer-alist
             '((derived-mode . calendar-mode)
               (display-buffer-reuse-mode-window display-buffer-below-selected)
               (mode . (calendar-mode bookmark-edit-annotation-mode ert-results-mode))
               (inhibit-switch-frame . t)
               (dedicated . t)
               (window-height . fit-window-to-buffer)))

(add-to-list 'display-buffer-alist
             '((derived-mode . reb-mode) ; M-x re-builder
               (display-buffer-reuse-mode-window display-buffer-below-selected)
               (inhibit-switch-frame . t)
               (window-height . 4) ; note this is literal lines, not relative
               (dedicated . t)
               (preserve-size . (t . t))))

;;;; ESSENTIAL packages to install

(use-package vertico
  :ensure t
  :config
  (vertico-mode 1))

(use-package marginalia
  :ensure t
  :config
  (marginalia-mode 1))

;;;; VERY USEFUL but not essential packages
(use-package orderless
  :ensure t
  :config
  (setq completion-styles '(orderless basic)))

(use-package consult
  :ensure t
  ;; All commands have their utility, but those are commonly needed.
  :commands (consult-buffer consult-line consult-outline consult-find consult-grep))

(use-package embark
  :ensure t
  :bind
  ;; Embark is helpful in every context, though there are other ways
  ;; to do what it does.  Where it stands out is in its ability to
  ;; deal with all the minibuffer results.  The equivalent of those
  ;; two commands should be a core Emacs functionality.
  ( :map minibuffer-local-map
    ("C-c C-c" . embark-collect)
    ("C-c C-e" . embark-export))
  :config
  ;; Needed for correct exporting while using Embark with Consult commands.
  (use-package embark-consult
    :ensure t
    :after consult))

;; Useful when combined with `delete-by-moving-to-trash'.
(use-package trashed
  :ensure t)

[ The video will be recorded. ]

This is a spontaneous live stream. The stream starts in ~20 minutes. I will continue maintaining my packages. My plan is to start with Denote and then move to TMR. Depending on how I do, I will check some of my other packages as well.

Mark your calendar for next Thursday. I will do another live stream with Sacha Chua. We will talk about Emacs and I will check on her progress since our last meeting. I am looking forward to it!

Note that the event will be recorded.

UPDATE 2026-04-13 18:00 +0300: I wrote the package during the stream: https://github.com/protesilaos/modus-themes-exporter.

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

Today, the 13th of April 2026, at 15:00 Europe/Athens I will do a live stream in which I will develop the new modus-themes-exporter package for Emacs.

The idea for this package is based on an old experiment of mine: to get the palette of a Modus theme and “export” it to another file format for use in supported terminal emulators or, potentially, other applications.

My focus today will be on writing the core functionality and testing it with at least one target application.

Prior work of mine from my pre-Emacs days is the tempus-themes-generator, which was written in Bash: https://gitlab.com/protesilaos/tempus-themes-generator.

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

At 14:00 Europe/Athens I will hold a live stream about Emacs. Specifically, I will work on my modus-themes package.

The idea is to write more tests and refine the relevant functions along the way.

I am announcing this -45 minutes before I go live. I will keep the chat open in case there are any questions.

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

Tonight I will work on my denote package. There is a feature branch I implemented this morning and am now ready to continue refining the code. The immediate goals:

• Update unit tests that are still calling deprecated functions.
• Write new tests, starting with the denote-dired command and all its ancillary functions.
• Review all the commands that filter the query buffers (which are produced by commands such as denote-grep, denote-backlinks, denote-query-contents-link).
• Edit the manual accordingly.

I expect the stream to go on for 2-3 hours, but we will see.

I will keep the chat open in case there are any comments. I am happy to respond to them.

The other day I had a coaching session with Sacha Chua. Sacha asked me if she could record and publish it, to which I agreed. More here: https://sachachua.com/blog/2026/04/yayemacs-10-emacs-coaching-with-prot-packaging-emacs-lisp//.

Our next meeting will be done live on the 16th of April 2026 at 10:30 America/Toronto, 17:30 Europe/Athens time: https://youtube.com/live/djE_pVlgDHg.

I will check with Sacha how she imagines doing this. Though I am the laissez faire type, so will adapt as we go.

[ Note that all my coaching sessions are private: I never share details of my meetings. This is an exception because Sacha asked me about it. ]

Sequence notes are created in relation to other notes, as parent, child, or sibling. denote-sequence communicates such relationships by writing a “sequence” to the file name, in accordance with the Denote file-naming scheme (technically, it uses the optional SIGNATURE component of the file name, which is defined as a free-form field for users to use as they see fit—so this is just one application of it).

The package supported two schemes before

The exact presentation of such sequences is subject to the user option denote-sequence-scheme. The package has hitherto supported two schemes, the numeric and alphanumeric.

In the numeric scheme, each level of depth is delimited by the equals sign. The sequence 1=2=3 thus has three levels of depth. It means “the third child of the second child of the first parent”.

By contrast, the alphanumeric scheme relies on the alternation between numbers and letters to communicate levels of depth. The above example is thus expressed as 1b3.

The new alphanumeric-delimited scheme

Many users have told me that the alphanumeric scheme looks cleaner. Though I think it is hard to read when sequences get really long, like 2a13c6d2a. To this end, the new sequence scheme augments the alphanumeric style with delimiters that are placed after the first level of depth and every third level of depth thereafter. Thus: 2=a13=c6d=2a.

Users may find this easier to work with.

Remember the denote-sequence-convert command

This command has been part of the package since its inception. It can convert from one sequence scheme to the others.

denote-sequence-convert has a “do what I mean behaviour” with regard to which file or files it should operate on:

• When called from inside a file with a Denote sequence, it operates on the current file.

• When called from a Dired buffer, it operates on all the marked files.

• When there are no marked files in the Dired buffer, it operates on the file at point.

The target sequence scheme for the conversion is whatever is assigned to the user option denote-sequence-scheme. If, however, denote-sequence-convert is called with a prefix argument (C-u by default), then it will prompt for the target sequence scheme.

Coming in version 0.3.0

I just merged the code into trunk. Users who are building the package from source can try the new feature right away. Otherwise, it will be available in the next stable version of the package. I hope to have that ready some time in mid-April.

• Package name (GNU ELPA): denote-sequence
• Official manual: https://protesilaos.com/emacs/denote-sequence
• Git repository: https://github.com/protesilaos/denote-sequence
• Backronym: Denote… Sequences Efficiently Queue Unsorted Entries Notwithstanding Curation Efforts.

I maintain a strict privacy policy with everyone I meet. Specifically, I do not say anything about our meeting. But since Sacha has already published this information, I am happy to do this in the open.

What follows are some comments on her post.

Testing interactive functions

writing tests, especially for things that are more interactive

What helps here is to think of the interactive part as the way to get the arguments. If the interactivity is more involved, then you want to think how it can be broken down into smaller routines. Each routine should eventually be reduced to a function that can be called non-interactively with a certain argument. This way, your tests are easier to reason about.

Consider this example:

(defun my-greet-person (name)
  "Return Hello string to person with NAME."
  (format "Hello %s" name))

The substantive part of the test would be something like this:

(let ((name "Sacha"))
  (string= (my-greet-person name) "Hello Sacha"))

Now add interactivity to the function:

(defun my-greet-person (name)
  "Return Hello string to person with NAME.
When called interactively, prompt for NAME.  Else NAME is a string."
  (interactive (list (read-string "Whom to greet: ")))
  (format "Hello %s" name))

Even though this function can be called interactively, the test is the same because the interactive simply sets the value of name.

There will, of course, be more complex scenaria. We can think how best to approach them. Though this is the general idea.

Navigating Lisp code across many files

navigating code that might be scattered in literate config files or in Emacs Lisp files

What I find helpful:

• Use the Emacs bookmarking system. I add a bookmark for anything I visit frequently. Then I can find what I need with bookmark-jump or consult-buffer (from Daniel Mendler’s consult package).
• Have a single root for all your programming projects. In my case this is ~/Git/.
• In that directory, create subdirectories with areas of interest. One of them should be specific to the projects you maintain. For example, I have ~/Git/emacs-community/ and ~/Git/Projects/. The latter consists of everything I develop/maintain.
• With these directories in place, you can always rely on a recursive Grep to find what you need.
• Otherwise, we have xref-find-definitions as well as all the help functions like describe-function which normally link to the file where the definition is.

Sharing with others

If I get better at sharing what I’m working on, I might be able to connect with more people and bounce ideas around.

Getting better is nice. I think here the goal is to structure what you are sharing in a certain way. Then people can use it more easily. Once that happens, you will receive more feedback.

Also, accountability might help me nudge this over the threshold.

This is key. When we make a promise in earnest, we are motivated to deliver on it. The fact that you have published this adds to the effectiveness of it.

I’m curious about other people’s workflows for sharing. I like joining meetups, but I tend to share stuff only if no one else has anything planned, because I have my blog and my YouTube channel in case I want to share anything with a wider group of people. I just have to actually post things.

Each person is different and there is no one answer to rule them all. What I do, as someone who publishes on a number of topics, is to reach a point that is an honest representation of my current level. This point is not approaching perfection, as that is a trap. If it were about perfection, I would never publish anything!

Once I do what is within my current level, I am casual about it. In other words, I do not need to prove that I am worthy of it—I am already there and this is my current normal state. This makes the process of writing less emotionally challenging (well, not challenging at all). It also opens me to learn more. I am not defensive or argumentative because, fundamentally, I feel secure with what I have: I am not hiding something and do not worry about what others may think.

About your case, I get the impression that you are already improving your content. It starts by recognising that there is improvement to be had. Then, you write blog posts such as the one I am now commenting on, which show that you have put thought into your processes. In other words, you are mindful of your current state. Whatever I may point out during our meeting will thus be easier for you to incorporate in your thinking. Why? Because you already know the space, as it were, and so you will have a good intuition of where to put the new thing.

Getting used to streaming

Streaming: Still need to get the hang of talking to myself or having half-conversations with chat: can be worked around by scheduling a session with Prot and opening it to the public

I am happy to do this in public. Either as a coaching session or some collaborative live stream. We can discuss the details.

At any rate, “practice makes perfect”. The only way to get used to talking to the camera is to do it enough times. I can talk at length, though I still find it hard to laugh when I am by myself, so I look dead serious in all of my monologues. Whereas, say, in the “Prot Asks” series I often laugh. This is because I have a natural response towards someone. Talking to the selfie camera does not create in me the same friendly emotions.

Sharing code

renaming things when I want to move them to a library

Before finding a name, you need to have a clear vision for the package: what is it meant to do. Then try to think about words that describe either the goal or the workflow. Use phrases, like what you have with “speech input”. Those work fine.

Come up with placeholder names if you are not sure. Then, once you are ready to share the package, do a final round of thinking to check if you can think of a more suitable name. Otherwise just use some descriptive phrase.

This concerns the prefix for the entire package. Though your code may still consist of different areas of focus. For example, in my denote package there is a subset of functionality related to “rename” operations. All of those share a compound prefix of the name of the package plus the name of the area they are specialising in like this helper function: denote-rename-buffer--format. By the name alone, I can tell that it relates to the “rename” operation and, specifically, is ancillary to denote-rename-buffer.

I can provide concrete suggestions for your code.

duplicating small functions (ex: simplify string)

You may choose to put those in their own package. Though I personally do not mind a little bit of duplication/repetition when that is easier to maintain. The principle of not repeating yourself is good in general, though there are cases where trying to avoid it is not worth the effort.

figuring out how to make it possible for someone else to start using my stuff

For any non-trivial code you write, you want to treat it like its own “package”. In other words, it exists in a file of its own, it has all the require calls for its dependencies, defines defcustom variables if it must, uses autoload where relevant, and has a provide call at the end. Even if you never move it out of your configuration, you have already done the work of clearing up your thoughts/code. Others will already benefit from that, as they can now copy the file with greater confidence in its utility.

Questions for Prot

Meta: what are people finding useful for coaching and behaviour change, like learning new keyboard shortcuts or workflows?

Each person has their own goals. Some enjoy a pair programming session. Others like me to check on their progress and to provide feedback. Plus, there is more than the purely Emacs component: I make comments about matters of perspective, whether it is about some piece of code or life in general.

Those granted, I do not collect any data about the people I meet. I do not ask them for testimonials or feedback. I prefer not to do that because I do not wish to ever have to handle private information. I like my meetings to be nice and simple. Plus, I do not want to manipulate or influence the behaviour of people.

Your literate config exports to individual .el files. I could probably do something similar to separate my functions from my personal config in order to make it easier for people to reuse parts of my config. Is it worth doing so? Do people tell you that they use those private Emacs Lisp files by loading them, or do they mostly rely on your published packages?

Most rely on my packages. I design those to be as flexible as possible and maintain them accordingly.

The individual .el files of my configuration are helpful to me. I stay in the flow of designing my code in a package-ready way. If anybody needs to use it, then they already have something that is close to an actual package.

Do you have some tweaks to make it easier to jump to function definitions considering a literate configuration?

No, I have not had a need for this. When I choose to work on some part of my configuration, I navigate to the relevant heading (with something like consult-outline) and then use org-edit-special to edit the source block.

You will show me what you have been doing, which may give me some ideas.

What’s your general process for migrating things from your config to a repository or package?

It all starts with splitting the code into many .el files. Make sure one file is not entangled with other files. Or, at least, put in the effort to list every other file as a dependency and write the necessary require for it.

Have one such file for each area of focus. This way you can reason about what you have and what may be missing. A clear initial idea will determine the direction of the package long-term. The reason is that it establishes boundaries: what to do and what not to do.

From there, you can decide if some file is of value to other users. If you think it is, then start implementing defcustom variables for it, define the commands that users would want, and have autoload directives for them if they are meant as points of entry.

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

At 21:30 Europe/Athens time I will do a live stream (~30 minutes from this writing). The plan is to continue some of the work I am doing on my denote-sequence package for Emacs.

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

I do not have any work this evening, so I will do a live stream. My plan is to do some programming. I have a new idea for the denote-sequence package that I will try to implement.

If there are any questions from the chat, I will answer them. They can be about what I will be working on or any other topic.

Talk to you soon!

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.1.0 on 2026-03-23

This version introduces minor refinements to the underlying code as well as four new themes.

The new themes are as follows:

• doric-almond: A light theme that combines green and magenta colours. It evokes a feeling of early springtime, as the almond tree is among the first to bloom.

• doric-coral: A light theme with a warmer feel that combines red, orange, and cyan colours against a sandy backdrop.

• doric-magma: A dark theme with a dominant red and orange style. The combination of those intense hues with lighter greys creates the necessary balance.

• doric-walnut: A dark theme with an overall green style, drawing inspiration from the broad leaves of the walnut tree. The green colours are combined with shades of brown and grey to make for a pleasant presentation.

Enjoy!

This is a holistic introduction to Emacs: how useful it is and how it champions free software. It is a modified version of the talk I did for the “FLOSS @ Oxford” event, organised by people at the University of Oxford. This is the page I wrote about that event: https://protesilaos.com/codelog/2026-03-12-my-emacs-talk-floss-oxford/.

Table of Contents

1. This is a holistic introduction to Emacs
2. Emacs as a capable text editor
3. Support for Unicode
4. Include several fonts on the same page
5. Emacs can display graphics alongside text
6. Emacs is an extensible text editor
7. Extending Emacs creates a community
8. The extensibility of Emacs happens live
9. My view without the “presentation mode”
10. Emacs puts you in control of your computing
11. Your control extends to all workflows
12. For an integrated computing environment
13. Many apps do not combine nicely
14. Emacs makes your workflow consistent
15. Integrated computing in practice
16. Emacs makes integration easier
17. Integration gives you emergent properties
18. This is plain text that works like a slideshow
19. Consistency facilitates productivity
20. Consistency remove the cognitive burden
21. The consistency of Emacs in action
22. Use Emacs Lisp to configure everything
23. Learning Emacs Lisp improves the experience
24. Emacs embodies software freedom
25. The freedom of Emacs helps with learning
26. Emacs is not only for programmers
27. You benefit from all the Emacs extensions
28. Some powerful extensions are built-in
29. The documentation culture of Emacs
30. Most packages have high quality manuals
31. Emacs has a steep learning curve
32. Do not skip the manuals
33. Adjust your expectations
34. Why it is worth learning how to use Emacs
35. The initial effort pays off long-term
36. Good luck and have fun!

Hello everyone! My name is Protesilaos, also known as “Prot”.

This presentation is a modified version of the talk I gave last night at the FLOSS @ Oxford event: https://ox.ogeer.org/event/computing-in-freedom-with-gnu-emacs-protesilaos-stavrou.

It was an event organised by people from the University of Oxford. I thank them for giving me the opportunity to participate in their programme.

I want to have this modified version here for people who do not read my website. They may not be aware that I talked at this Oxford event.

Having the video on this platform means that everyone can benefit from it.

1 This is a holistic introduction to Emacs

In this presentation I will talk to you about GNU Emacs, or simply, “Emacs”. Emacs is a program you run on your computer. I am using it right now for this presentation.

Emacs is free or libre software. It allows you to read all of its source code, to modify it, and to share it with your customisations. Thus you contribute to—and benefit from—a community of welcoming Emacs users.

I will tell you what all this means in practice and how you can improve your computing experience by switching to Emacs.

2 Emacs as a capable text editor

When you first start using Emacs, it feels like a regular text editor program.

You move the cursor around and edit text. Nothing obviously impressive out-of-the-box.

As a text editor, Emacs is highly capable. It has all sorts of keyboard shortcuts that let you efficiently operate on text.

You can control Emacs without relying on the mouse, if you want.

3 Support for Unicode

Emacs supports the Unicode standard, which is essential for inclusivity of peoples.

The world’s scripts can be expressed in Emacs. I am a native Greek speaker.

I can use functionality that is built into Emacs to switch to the Greek alphabet in order to write something, such as to say «καλησπέρα», which means “good evening”.

I can even spell out “Dao De Jing” (道德经), which is the title of a book from ancient China.

Plus emoji: 🦚🦬🐉.

4 Include several fonts on the same page

The multitude of scripts can be present in the same document.

This is an advantage for multilingual people like myself or those who do research that involves many natural languages.

Emacs can combine several fonts in the same page as well as different colours.

Each fonts can have its own attributes, such as for its relative size and typographic intensity.

Same idea for colours.

On my screen right now, I am already combining two different font styles: that of the heading and the body of the text.

5 Emacs can display graphics alongside text

Emacs does not limit you to a text-only interface. It can also display images and PDF documents. Below I have a link to an image file. I will now type a keyboard shortcut to reveal this image. And I will do it again to hide it.

This, by the way, is a spot somewhere in my mountains.

6 Emacs is an extensible text editor

Although you can benefit from using Emacs as a generic text editor, what really appeals to people like me is the option to extend Emacs.

“Extend” here means to introduce new functionality; functionality that is not available in the default program you install on your computer.

These extensions are written in the same programming language as most of Emacs. It is a programming language called “Emacs Lisp” or “Elisp”.

You can extend Emacs on your own, by writing some program in Elisp, or you can download an existing extension that the community has made available.

7 Extending Emacs creates a community

For example, when I create a new extension for Emacs, I publish it under the terms of a free software license—the same terms that Emacs uses.

Others can then download my extension and use it as they prefer. If they want, they can make their own modifications on top, which may introduce other extensions that I had not thought of in my original implementation.

And if those users follow my example, then I can also benefit from their additions once they publish them.

As such, there exists a community of enthusiastic users of Emacs who care about sharing their works with the rest of the world.

8 The extensibility of Emacs happens live

Users can extend Emacs by running some Emacs Lisp program. Such a program can be as short as a single line. Or it can be as long as it needs to be. It does not matter.

Users run the program and Emacs immediately does what the program renders possible.

For example, I am doing this presentation inside of Emacs. But Emacs does not have a “presentation mode” built into it. I thus developed my own extension which empowers me to do what I am doing right now.

Let me toggle off my presentation mode to show you what I mean.

9 My view without the “presentation mode”

Notice that the display has changed.My main font is monospaced now.

The headings are smaller than they were before: they are the same size as the rest of the text. There is no number next to the heading anymore.

Then, there is a bar at the bottom of my screen, with information about what I am working on. On the side, there are line numbers, indicating where my cursor is in this file. Plus, my current line is highlighted with a distinct background colour. Let me shift it up and down to illustrate this point.

All those elements are useful while I am programming. But they look distracting when I wish to focus on some portion of text. So, I just type the keyboard shortcut I have and—voilà!—I get the style I prefer.

10 Emacs puts you in control of your computing

You may wonder: why do I even need a customisable text editor?

The answer is about control. You are in charge of what you use and how you use it. You can piece together a workflow that works the way you prefer.

This presentation mode I toggled on and off earlier behaves exactly how I want. I decided which set of interface tweaks to apply. Another user may have a different preference in this regard.

For instance, they may like having line numbers on the side of the screen. There is no right or wrong answer. What matters is that Emacs gives us the means to do what makes sense to us.

11 Your control extends to all workflows

Now apply this principle to everything you can use Emacs for: this will generally be a text-centric project.

I run my agenda exclusively through Emacs.

I handle all my email correspondence with Emacs.

I do programming and I write prose, such as blog posts for my website and books or technical manuals.

For each of these, I know that Emacs will empower me to perform my tasks without arbitrary restrictions.

Emacs lets me use Elisp to modify how I do my emails, for instance, and how I present tasks in my custom agenda view.

12 For an integrated computing environment

Without Emacs, I would not be in a position to control my computing experience to the extent I do.

The reason is that I would be relying on many different applications. Each application has its own interface and design paradigms.

Each application is configured, if at all, in a way that is specific to it. Customisations in one application do not carry over to other applications.

And, if we consider the important implementation details, each application may configurable in its own programming language.

In other words, that is not an integrated computing experience.

13 Many apps do not combine nicely

To have the same degree of control that Emacs makes possible, I would have to hope that somehow all those disparate applications would conspire in my favour.

That is wishful thinking.

The reality is that piecing together many different applications is an exercise in frustration and the path to a life of ever-distracting context switching.

14 Emacs makes your workflow consistent

Having everything I need inside of Emacs ensures that things happen in a manner that is consistent.

All customisations are written in the same programming language, namely, Emacs Lisp.

What I define for one context, such as this “presentation mode”, can be used in another context.

For example, I can have this presentation style enabled when I read emails. Why?

Because it can make it more comfortable for me at a certain hour. And I can even automate this with conditional logic, so it happens on its own when I open a new email under certain circumstances.

15 Integrated computing in practice

When you work with many applications that do not play nicely together, you cannot do something that the developers have not envisaged.

For example, your email client likely does not have access to a “presentation mode”. Same for your other applications.

Similarly, your many applications will not necessarily know how to read and interpret the configurations you have in one application.

Suppose you define your favourite colour scheme for your email client. You take the time to consider the harmonies and use precise typography to your liking.

Now, you switch to your calendar application and none of that work carries over: you have to do it again, assuming it is even possible.

16 Emacs makes integration easier

Colours and styles may seem like relatively small issues. But they are indicative of something greater: disparate applications do not work together seamlessly.

Emacs does not have this problem. You define something for one context you have in mind and, eventually, it can be used in another context that initially you had not even thought of.

For example, in my Emacs I wrote a small function to quickly copy the “thing” at where the cursor is. This is useful when I do programming, as the “thing” can be an entire expression, like the definition of a function. But the “thing” may also be a link that I got in my email.

I had not thought of that use-case in advance. Yet it was trivial to have my function do what I need in this once unforeseen situation.

17 Integration gives you emergent properties

The integrated computing environment of Emacs is more than the sum of its parts.

This is because you can combine different pieces of functionality in ways that the original developer had not foresaw.

You do not simply have your writing, your email, your agenda, et cetera, in Emacs.

You have the functionality of one in tandem with the functionality of another. And you draw linkages between them as you see fit.

Consider once again this presentation I am now doing. What I have in front of me is the transcript of my talk. This is a plain text document, which I can edit live. Let me CAPITALISE THIS to illustrate the point.

18 This is plain text that works like a slideshow

I have made this file look a little bit like a series of slides.

Notice that if I scroll up and down, which I will do shortly, you only get the current section I am reading from: you do not have access to the rest of the document. I will scroll up and down now.

This is a feature known as “narrowing”. Let me “widen” the view and then try to scroll again. You will now be exposed to the rest of the text.

The original developer of this “narrowing” facility did not know how someone like me would make use of it.

I have it here for my presentation. Each heading becomes its own pseudo-slide. I have narrowing for my emails, when I want to read a portion of the text in a more focused way. It is all about how I choose to do my computing.

19 Consistency facilitates productivity

For many years before switching to Emacs, I did not enjoy using the computer.

I needed too much time to accomplish every single task.

I could never find any of my files in a timely fashion because there was no program that would enforce on my behalf a predictable file-naming scheme.

All my notes were eventually not retrievable. This made them useless. Data you save is only good if you can find what you are searching for.

My music collection was inconsistent because I needed special software to write the metadata… In short, I was not as productive as I would like to be.

And, above all, it was not fun.

20 Consistency remove the cognitive burden

Most of my work at the time was centred around the email client and a word processor.

The email client had its own subsystem for handling reminders for tasks. The format of those tasks was not interoperable with other programs.

I could not access the tasks with my favourite text editor. I thus had to use the clunky interface of the email client, which was never designed for task management—and was not configurable.

And then I had all the cognitively burdensome annoyances of my two applications looking quite different from each other.

My emails did not behave like my documents, which made it harder for me to flip between the two and continue writing. I would roll my eyes each time.

21 The consistency of Emacs in action

Emacs has elevated my computing experience.

I have been much more productive ever since I switched to it. Allow me to demonstrate a tiny bit of what I do each day.

I will temporarily exit the presentation mode in this window.

Then, in the bottom half of my screen, I will open my email client to read a message I got.

Once you follow my switch to the email client, I will hide the window that shows this presentation.

After that I will switch to my agenda to record a task and review what I have to do.

All this is done inside of Emacs. Time for action!

22 Use Emacs Lisp to configure everything

What I just demonstrated is a very small part of what I do every single day.

There is much more, though I cannot cover it all in this presentation.

The point, however, is the consistency of the experience; consistency throughout.

I have customised my email client by writing some Emacs Lisp code for it. I have done the same for the custom agenda I have. And much more.

Every time I work with Emacs Lisp, I acquire skills that are applicable outside the confines of the problem I am solving.

For example, by configuring email the way I want, I pick up programming skills that I can then apply to the design of my custom agenda.

23 Learning Emacs Lisp improves the experience

This is an investment that pays off more and more.

Emacs will adapt to match my evolving needs. Each new workflow I incorporate in my Emacs setup will thus benefit from all the knowledge and features I have accumulated.

I do not have to relearn everything because I am not switching to another application.

I do not have to throw away all the work I did all those years. It is here to stay.

I do not feel the pressure to try the new shiny app of the day. I did that many times and always regretted it. I lost my data and time in the process.

Because I am rooted in this stability of Emacs, I remain productive and efficient.

24 Emacs embodies software freedom

I mentioned earlier that Emacs is free or libre software. This means that you can read its source code, modify it, and share your changes with others.

Emacs has a license that gives users power. There is no corporation that can take Emacs away from us. It belongs to the community and we all tend to its wellness.

In the case of Emacs, software freedom is not just about the license. It informs how you use the program. Emacs makes such freedom an irriducible part of its functionality.

You can, at any moment, ask Emacs what does a keyboard shortcut actually do. What is the definition of a function. What is the value of a variable. And you may even access the source code to check for yourself.

I will demonstrate this right now.

25 The freedom of Emacs helps with learning

I actually learnt to program in Emacs Lisp by exercising this freedom.

I would tinker with Emacs and continuously check on its state. What does this do? Which function is called by that keyboard shortcut? How is a program able to determine if the file is not saved?

I wanted to learn how, for example, we move down a line. From there, I learnt that we can move down many lines at once.

I then figured that we can move down the lines and then also do something else, such as place the cursor at the end of the line and create a pulse effect to bring attention to it.

Not only did I learn how to configure Emacs, I even wrote tens of extensions for it. I have also authored a libre book titled “Emacs Lisp Elements”. This freedom is not theoretical. I did not have a background in programming, yet was empowered to act and to grow as a person.

26 Emacs is not only for programmers

Emacs is extended with Emacs Lisp. If you know how to program in that language, you can be extra opinionated and particular about the way Emacs facilitates your work.

But even without any expertise of this sort, you can still do much of what you like. Remember that I started using Emacs without a background in programming.

Emacs blurs the distinction between user and developer. Many of the developers actually start out as users like myself. They learn along the way and, eventually, they contribute to the development of Emacs.

I even have written code that is in core Emacs: my modus-themes as well as several other smaller patches.

27 You benefit from all the Emacs extensions

The Emacs community has developed a rich corpus of extensions. You do not need to invent anything right away in order to be productive.

We call these extensions “packages”, as they are distributed in a way that makes them easy to install and then use directly.

The Emacs program you will download on your computer ships with plenty of packages built-in.

Depending on your needs, you may not even have to install anything from what the community has to offer.

Though if you want a package, it is fairly easy to get it and run it on your system.

Emacs is not picky about how you should use it. You are empowered to be opinionated.

28 Some powerful extensions are built-in

For example, Emacs ships with a package called org or “Org mode”. At its core, this is a markup language. I am using it right now in this document.

Notice how lines that start with an asterisk function as headings. This is what the markup does.

Org lets you write documents, including books, handle your tasks, organise your agenda, and much more. It is a powerhouse.

There are so many things to discover in Emacs as well as the broader package ecosystem.

Emacs as a whole provides high quality documentation that explains everything.

29 The documentation culture of Emacs

When you install Emacs, you get with it plenty of technical manuals. There is also an interactive tutorial to help you make sense of the basics.

Furthermore, when you ask Emacs for help about the definition of a function or the value of a variable, you receive the documentation for the thing you are looking for.

The expectation for all contributions to the official Emacs program is that the code is well-documented and the manual is updated accordingly.

30 Most packages have high quality manuals

Core Emacs sets the standard of what good documentation looks like. Package developers follow this practice.

For example, my denote package has a manual that is over 7500 lines long. It exceeds 52000 words. In it users find detailed instructions as well as code snippets that they can copy and use outright. And this is not the exception. All my packages are like that, to the extent necessary. Most other developers do the same.

As a community, we have access to so much knowledge for free and in freedom. If we are committed enough, we can learn from others and thus become better ourselves. We do so in a spirit of sharing and caring. For me, specifically, all this was of great help. I am self-taught because I received all those great resources from the community. I consider it my duty to give back in kind.

31 Emacs has a steep learning curve

Because Emacs is extensible, there is practically no limit to what you can do with it. At least this is the case for all tasks that are text-heavy.

Emacs will just gracefully evolve to match your requirements, provided you can extend it on your own or with a relevant package.

The downside, however, is that it is not easy to become proficient in it. If you are committed, you can learn the basics within the first few days.

Though you will need to invest a few weeks or months to become skillful. It depends on how much effort you put into it, what sort of work you are doing, and what your background is.

I learnt the basics within a few days. I started writing my own Emacs Lisp within weeks. And within a year I had my modus-themes moved into core Emacs.

32 Do not skip the manuals

Several “starter kits” are available to help you get started. They set things up so that you do not need to discover everything at the outset.

The new version of Emacs (Emacs 31) will even come with a “newcomers theme”, which configures several settings in advance.

These can make the learning curve a bit smoother. For me, anything that improves the onboarding experiences is a plus.

Though I do not think that Emacs will ever become “plug and play”. This is due to its sheer depth and extensibility. It does so much that you still need to invest the time and effort into learning it.

However you start, the most reliable study involves the manuals. Those are written for the benefit of the user. Read them carefully.

33 Adjust your expectations

What I can say with confidence is that Emacs is not for tourists. You cannot switch to it with the expectation that you will have a good time right away.

No. That will not work. There simply is no shortcut to excellence.

I encourage you to take it one step at a time. Emacs will make you more productive, provided you are patient enough to unlock its virtually boundless potential.

Take it slow and be methodical. Rely on the official manual no matter your starting point. Read from it and gradually incorporate its insights into your workflow.

The community—myself included—has plenty of resources to complement that study. Blog posts, video tutorials, books… But do not skip the official manual. Learning it slowly means that you will become proficient faster than you otherwise would.

34 Why it is worth learning how to use Emacs

I already talked about the technical side of things with regard to the integrated computing environment. Now combine that with two facts:

1. Emacs is free software. This means that we as a community are its custodians.
2. GNU Emacs has been around since the 1980s. It will stay relevant for decades to come.

Emacs is not old, it is timeless. This is because it can be extended in a spirit of freedom.

Whatever new technology or idea we have as a collective, we can eventually bring it into Emacs.

This way, our integrated computing environment adapts with the times.

Thus Emacs remains ever-relevant.

35 The initial effort pays off long-term

Couched in those terms, the initial effort you will put into learning Emacs is actually not that much.

You have to maintain a longer-term view of this project.

If you are patient, Emacs will be one of the most reliable tools you will ever use throughout your life. And I say this as a handy man myself, someone who uses many tools for manual labour, having built the house I am in, among others.

I switched to Emacs in the summer of 2019. It is almost 7 years already. I see no reason not to use it for the next 7 years, if I can.

I will still want to write articles, do programming, maintain my agenda, and probably make presentations like this one.

36 Good luck and have fun!

Remember that you will not learn Emacs over the weekend. You are in it for the long-term. Take it slow and you will enjoy the experience.

This is all I have for you today folks. Thank you very much for your attention!

You can find this and everything else I publish on my website: https://protesilaos.com.

I had written the transcript ahead of time to make my presentation more accessible. The event was held live as a Jitsi call. There were questions from participants, which I answered. A recording of the event will be available before the end of this week. I will update this article to include a link to the video.

UPDATE 2026-03-16 07:49 +0200: The video is here: https://ogeer.org/ox/rec/emacs/.

Below is the text of my talk. It is titled “Computing in freedom with GNU Emacs”. Note that some parts of my presentation only make sense in the video format, though I tried to describe in the transcript what I was demonstrating.

Table of Contents

1. Emacs as a capable text editor
2. Emacs can display graphics alongside text
3. Emacs is an extensible text editor
4. The extensibility of Emacs happens live
5. Emacs puts you in control of your computing
6. The promise of an integrated computing environment
7. The integrated computing environment in practice
8. Integration gives you emergent properties
9. Consistency facilitates productivity
10. The consistency of Emacs in action
11. Use Emacs Lisp to configure everything
12. Emacs is the embodiment of software freedom
13. You do not need to be a programmer to use Emacs
14. The documentation culture of Emacs
15. Emacs has a steep learning curve
16. Why it is worth learning how to use Emacs
17. Good luck and have fun!

Hello everyone! My name is Protesilaos, also known as “Prot”. I am joining you from the mountains of Cyprus. Cyprus is an island in the Eastern Mediterranean Sea.

In this presentation I will talk to you about GNU Emacs, or simply, “Emacs”. Emacs is a program you run on your computer. I am using it right now for this presentation.

Emacs is free or libre software. It allows you to read all of its source code, to modify it, and to share it with your customisations. Thus you contribute to—and benefit from—a community of welcoming Emacs users.

I will tell you what all this means in practice and how you can improve your computing experience by switching to Emacs.

Emacs as a capable text editor

When you first start using Emacs, it feels like a regular text editor program. You move the cursor around and edit text. Nothing obviously impressive out-of-the-box. As a text editor, Emacs is highly capable. It has all sorts of keyboard shortcuts that let you efficiently operate on text. You can control Emacs without relying on the mouse, if you want.

Emacs supports the Unicode standard, which is essential for inclusivity of peoples. The world’s scripts can be expressed in Emacs. I am a native Greek speaker. I can use functionality that is built into Emacs to switch to the Greek alphabet in order to write something, such as to say «καλησπέρα», which means “good evening”. I can even spell out “Dao De Jing” (道德经), which is the title of a book from ancient China. Plus emoji: 🙃.

The multitude of scripts can be present in the same document. This is an advantage for multilingual people or those who do research that involves many natural languages.

Emacs can combine several fonts in the same page as well as different colours. Each fonts can have its own attributes, such as for its relative size and typographic intensity. Same idea for colours. On my screen right now, I am already combining two different font styles: that of the heading and the body of the text.

Emacs can display graphics alongside text

Emacs does not limit you to a text-only interface. It can also display images and PDF documents. Below I have a link to an image file. I will now type a keyboard shortcut to reveal this image. And I will do it again to hide it.

[Here is an image that I do not need to reproduce on my website: the specific image does not matter]

This, by the way, is a spot somewhere in my mountains.

Emacs is an extensible text editor

Although you can benefit from using Emacs as a generic text editor, what really appeals to people like me is the option to extend Emacs. “Extend” here means to introduce new functionality; functionality that is not available in the default program you install on your computer.

These extensions are written in the same programming language as most of Emacs. It is a programming language called “Emacs Lisp” or “Elisp”. You can extend Emacs on your own, by writing some program in Elisp, or you can download an existing extension that the community has made available.

For example, when I create a new extension for Emacs, I publish it under the terms of a free software license—the same terms that Emacs uses. Others can then download my extension and use it as they prefer. If they want, they can make their own modifications on top, which may introduce other extensions that I had not thought of in my original implementation. And if those users follow my example, then I can also benefit from their additions once they publish them.

As such, there exists a community of enthusiastic users of Emacs who care about sharing their works with the rest of the world.

The extensibility of Emacs happens live

Users can extend Emacs by running some Emacs Lisp program. Such a program can be as small as a single line. Or it can be as long as it needs to be. It does not matter. Users run the program and Emacs immediately does what the program renders possible.

For example, I am doing this presentation inside of Emacs. But Emacs does not have a “presentation mode” built into it. I thus developed my own extension which empowers me to do what I am doing right now. Let me toggle off my presentation mode to show you what I mean.

Notice that the display has changed. My main font is monospaced now. The headings are smaller than they were before: they are the same size as the rest of the text. There is no number next to the heading anymore. Then, there is a bar at the bottom of my screen, with information about what I am working on. On the side, there are line numbers, indicating where my cursor is in this file. Plus, my current line is highlighted with a distinct background colour. Let me shift it up and down to illustrate this point.

All those elements are useful while I am programming. But they look distracting when I wish to focus on some portion of text. So, I just type the keyboard shortcut I have and—voilà!—I get the style I prefer.

Emacs puts you in control of your computing

You may wonder: why do I even need a customisable text editor? The answer is about control. You are in charge of what you use and how you use it. You can piece together a workflow that works the way you prefer.

This presentation mode I toggled on and off earlier behaves exactly how I want. I decided which set of interface tweaks to apply. Another user may have a different preference in this regard. For instance, they may like having line numbers on the side of the screen. There is no right or wrong answer. What matters is that Emacs gives us the means to do what makes sense to us.

Now apply this principle to everything you can use Emacs for: this will generally be a text-centric project. I run my agenda exclusively through Emacs. I handle all my email correspondence with Emacs. I do programming and I write prose, such as blog posts for my website and books or technical manuals.

For each of these, I know that Emacs will empower me to perform my tasks without arbitrary restrictions. Emacs lets me use Elisp to modify how I do my emails, for instance, and how I present tasks in my custom agenda view.

The promise of an integrated computing environment

Without Emacs, I would not be in a position to control my computing experience to the extent I do. The reason is that I would be relying on many different applications. Each application has its own interface and design paradigms. Each application is configured, if at all, in a way that is specific to it. Customisations in one application do not carry over to other applications. And, if we consider the important implementation details, each application may configurable in its own programming language.

In other words, that is not an integrated computing experience. To have the same degree of control that Emacs makes possible, I would have to hope that somehow all those disparate applications would conspire in my favour. That is wishful thinking. The reality is that piecing together many different applications is an exercise in frustration and the path to a life of ever-distracting context switching.

Having everything I need inside of Emacs ensures that things happen in a manner that is consistent. All customisations are written in the same programming language, namely, Emacs Lisp. What I define for one context, such as this “presentation mode”, can be used in another context. For example, I can have this presentation style enabled when I read emails. Why? Because it can make it more comfortable for me at a certain hour. And I can even automate this, so it happens on its own when I open a new email.

The integrated computing environment in practice

When you work with many applications that do not play nicely together, you cannot do something that the developers have not envisaged. For example, your email client likely does not have access to a “presentation mode”. Same for your other applications.

Similarly, your many applications will not necessarily know how to read and interpret the configurations you have in one application. Suppose you define your favourite colour scheme for your email client. You take the time to consider the harmonies and use precise typography to your liking. Now, you switch to your calendar application and none of that work carries over: you have to do it again, assuming it is even possible.

Colours and styles may seem like relatively small issues. But they are indicative of something greater: disparate applications do not work together seamlessly.

Emacs does not have this problem. You define something for one context you have in mind and, eventually, it can be used in another context that initially you had not even thought of. For example, in my Emacs I wrote a small function to quickly copy the “thing” at where the cursor is. This is useful when I do programming, as the “thing” can be an entire expression, like the definition of a function. But the “thing” may also be a link that I got in my email. I had not thought of that use-case in advance.

Integration gives you emergent properties

The integrated computing environment of Emacs is more than the sum of its parts. This is because you can combine different pieces of functionality in ways that the original developer had not foresaw. You do not simply have your writing, your email, your agenda, et cetera, in Emacs. You have the functionality of one in tandem with the functionality of another. And you draw linkages between them as you see fit.

Consider once again this presentation I am now doing. What I have in front of me is the transcript of my talk. This is a plain text document, which I can edit live. Let me CAPITALISE THIS to illustrate the point. But I have made this file look a little bit like a series of slides. Notice that if I scroll up and down, which I will do now, you only get the current section I am reading from: you do not have access to the rest of the document. This is a feature known as “narrowing”. Let me “widen” the view and then try to scroll again. You will now be exposed to the rest of the text.

The original developer of this “narrowing” facility did not know how someone like me would make use of it. I have it here for my presentation. Each heading becomes its own pseudo-slide. I have narrowing for my emails, when I want to read a portion of the text in a more focused way. It is all about how I choose to do my computing.

Consistency facilitates productivity

For many years before switching to Emacs, I did not enjoy using the computer. I needed too much time to accomplish every single task. I could never find any of my files in a timely fashion because there was no program that would enforce on my behalf a predictable file-naming scheme.

All my notes were eventually not retrievable. My music collection was inconsistent because I needed special software to write the metadata… In short, I was not as productive as I would like to be. And, above all, it was not fun.

Most of my work at the time was centred around the email client and a word processor. The email client had its own subsystem for handling reminders for tasks. The format of those tasks was not interoperable with other programs. I could not access it with my favourite text editor. I thus had to use the clunky interface of the email client, which was never designed for task management—and was not configurable.

And then I had all the cognitively burdensome annoyances of my two applications looking quite different from each other. My emails did not behave like my documents, which made it harder for me to flip between the two and continue writing.

The consistency of Emacs in action

Emacs has elevated my computing experience. I have been much more productive ever since I switched to it. Allow me to demonstrate a tiny bit of what I do each day. I will temporarily exit the presentation mode in this window. Then, in the bottom half of my screen, I will open my email client to read a message I got. After that I will switch to my agenda to record a task and review what I have to do. All this is done inside of Emacs. Time for action!

Use Emacs Lisp to configure everything

What I just demonstrated is a very small part of what I do every single day. There is much more, though I cannot cover it all in this presentation. The point, however, is the consistency of the experience; consistency throughout.

I have customised my email client by writing some Emacs Lisp code for it. I have done the same for the custom agenda I have. And much more.

Every time I work with Emacs Lisp, I acquire skills that are applicable outside the confines of the problem I am solving. For example, by configuring email the way I want, I pick up programming skills that I can then apply to the design of my custom agenda.

This is an investment that pays off more and more. Emacs will grow or shrink to match my evolving needs. Each new workflow I incorporate in my Emacs setup will thus benefit from all the knowledge and features I have accumulated.

I do not have to relearn everything. I do not have to throw away all the work I did. It is here to stay. I do not feel the pressure to try the new shiny app of the day. And, because I am rooted in this stability, I remain productive and efficient.

Emacs is the embodiment of software freedom

I mentioned earlier that Emacs is free or libre software. This means that you can read its source code, modify it, and share your changes with others. Emacs has a license that gives users power. There is no corporation that can take Emacs away from us. It belongs to the community and we all tend to its wellness.

Software freedom is not just about the license. Emacs makes such freedom an irriducible part of its functionality. You can, at any moment, ask Emacs what does a keyboard shortcut actually do. What is the definition of a function. What is the value of a variable. And you may even access the source code to check for yourself.

I actually learnt to program in Emacs Lisp by exercising this freedom. I would tinker with Emacs and continuously check on its state. I wanted to learn how, for example, we move down a line. From there, I learnt that we can move down many lines at once. I then figured that we can move down the lines and then also do something else, such as place the cursor at the end of the line and create a pulse effect to bring attention to it.

Not only did I learn how to configure Emacs, I even wrote tens of extensions for it. I have also authored a libre book titled “Emacs Lisp Elements”. This freedom is not theoretical. I did not have a background in programming, yet was empowered to act.

You do not need to be a programmer to use Emacs

Emacs is extended with Emacs Lisp. If you know how to program in that language, you can be extra opinionated and particular about the way Emacs facilitates your work.

But even without any expertise of this sort, you can still do much of what you like. This is because the Emacs community has developed a rich corpus of extensions. We call these extensions “packages”, as they are distributed in a way that makes them easy to install and then use directly.

The Emacs program you will download on your computer ships with plenty of packages built-in. Depending on your needs, you may not even have to install anything from what the community has to offer.

For example, Emacs ships with a package called org or “Org mode”. At its core, this is a markup language. I am using it right now in this document. Notice how lines that start with an asterisk function as headings. This is what the markup does. Org lets you write documents, including books, handle your tasks, organise your agenda, and much more. It is a powerhouse. There are so many things to discover. Emacs provides high quality documentation that explains everything.

The documentation culture of Emacs

When you install Emacs, you get with it plenty of technical manuals. There is also an interactive tutorial to help you make sense of the basics. Furthermore, when you ask Emacs for help about the definition of a function or the value of a variable, you receive the documentation for the thing you are looking for.

The expectation for all contributions to the official Emacs program is that the code is well-documented and the manual is updated accordingly.

This is true also for packages that the community develops. For example, my denote package has a manual that is over 7500 lines long. It exceeds 52000 words. In it users find detailed instructions as well as code snippets that they can copy and use outright. And this is not the exception. All my packages are like that, to the extent necessary. Most other developers do the same.

As a community, we have access to so much knowledge for free and in freedom. If we are committed enough, we can learn from others and thus become better ourselves. We do so in a spirit of sharing and caring. For me, specifically, all this was of great help. I am self-taught because I received all those great resources from the community. I consider it my duty to give back in kind.

Emacs has a steep learning curve

Because Emacs is extensible, there is practically no limit to what you can do with it. At least this is the case for all tasks that are text-heavy. Emacs will just gracefully evolve to match your requirements, provided you know how to extend it.

The downside, however, is that it is not easy to become proficient in it. If you are committed, you can learn the basics within the first few days. Though you will need to invest a few weeks or months to become skillful. It depends on how much effort you put into it.

What I can say with confidence is that Emacs is not for tourists. You cannot switch to it with the expectation that you will have a good time right away. No. That will not work. There simply is no shortcut to excellence.

I thus encourage you to adjust your expectations. Emacs will make you more productive, provided you are patient enough to unlock its virtually boundless potential. Take it slow and be methodical. Rely on the official manual. Read from it and gradually incorporate its insights into your workflow. The community has plenty of resources to complement that study. But do not skip the official manual. Learning it slowly means that you will become proficient faster than you otherwise would.

Why it is worth learning how to use Emacs

I already talked about the technical side of things with regard to the integrated computing environment. Now combine that with two facts:

1. Emacs is free software. This means that we as a community are its custodians.
2. GNU Emacs has been around since the 1980s. It will stay relevant for decades to come.

Emacs is not old, it is timeless. This is because it can be extended in a spirit of freedom. Whatever new technology or idea we have as a collective, we can eventually bring it into Emacs. This way, our integrated computing environment adapts with the times.

Couched in those terms, the initial effort you will put into learning Emacs is actually not that much. You have to maintain a longer-term view of this project. If are patient, Emacs will be one of the most reliable tools you will ever use throughout your life. And I say this as a handy man myself, having built the house I am in, among others.

I switched to Emacs in the summer of 2019. It is almost 7 years already. I see no reason not to use it for the next 7 years, if I can. I will still want to write articles, do programming, maintain my agenda, and probably make presentations like this one.

Good luck and have fun!

Remember that you will not learn Emacs over the weekend. You are in it for the long-term. Take it slow and you will enjoy the experience.

This is all I have for you today folks. Thank you very much for your attention!

The presentation will be about 40 minutes long. I will then answer any questions from the audience. Anyone can participate: no registration is required. The event will be recorded for future reference. The link for the video call and further details are available here: https://ox.ogeer.org/event/computing-in-freedom-with-gnu-emacs-protesilaos-stavrou.

I will prepare a transcript for my talk. This way people can learn about my presentation without having to access the video file.

Looking forward to it!

• doric-almond (light)
• doric-coral (light)
• doric-magma (dark)
• doric-walnut (dark)

Each of them has its own character, while they all retain the minimalist Doric style. Below are some screenshots. Remember that these themes use few colours, relying on typography to establish a visual rhythm.

doric-almond

doric-coral

doric-magma

doric-walnut

Coming in version 1.1.0

All four themes are in development. I may still make some minor refinements to them, though I have already defined their overall appearance. If you like the minimalism of the doric-themes, I think you will appreciate these new additions.

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.

I had a ~2-hour chat with Joshua Blais, a fellow Emacs user, over at the @JoshuaBlais YouTube channel: https://www.youtube.com/@JoshuaBlais. We covered Emacs at length and also talked about general life issues.

The first topic we cover is how to place constraints on yourself in order to avoid backsliding into bad habits. This ties in to the themes of discipline and productivity that we discuss in some further length.

Joshua asks me how I got into Emacs and how I started writing/maintaining packages for it. We talk about how Emacs provides for an integrated computing experience. Learning Emacs Lisp allows you to have better control of Emacs.

In this light we comment on Guix and how it is also configurable in a dialect of Lisp. Joshua is using Nix and I learn more about that experience.

Coming back to Emacs, we comment on its relationship to the Unix philosophy. I think Emacs is compatible with Unix. Though my main point is how Emacs empowers us to use the computer in a productive way. It augments the experience.

Simple living and financial independence is another topic we cover. Joshua wants to know how I approach this issue. I explain how it is a matter of controlling your wants. Figure out what the parts of your lifestyle that you would not sacrifice. Then you know how much money you need for that lifestyle.

Joshua makes a connection of the simple life to Emacs and Unix tools. I comment on that as well. Once you start using Emacs and friends, you learn to appreciate the essentials. This you can then apply to other parts of your life.

We move to note-taking, where I comment about Denote. I explain how it is a file-naming scheme, which can also be used to write notes. What matters is how well we can retrieve information. Joshua explains how pen and paper helps him express his thoughts.

Learning on your own is our next point. Being an autodidact myself, I comment how it empowers you. You are able to have initiative and be more independent.

We then explore how things have infinite depth. This is how everything in the world is connected. This also relates to the point about the simple living, since you can have relatively few things that you keep understanding in depth.

Joshua asks me about discipline. This is a capacity we can build up. I give some examples.

Next on our list are mechanical keyboards. Joshua and I are using a split keyboard.

Then we explore the theme of using tools the right way. One example is the Internet as a whole. Another is with LLMs. It helps to know “why am I doing this”, as then you can understand when you are meeting your goals and when you are moving away from them. We explore this in further depth.

I comment on a common mistake we make where we think that the complex must be sophisticated and profound. Whereas there is profundity in simplicity.

We connect the dots through all these as we wrap things up.

Thanks to Joshua Blais for this chat. I had a good time and wish him all the best!

This has become easier since Emacs 29, which introduced a command-line flag called --init-directory. It is responsible for loading the init.el that is present in the given directory. For example:

# From a terminal or shell, run something like this:
emacs --init-directory=/tmp/test-emacs/

In other words, you can keep your regular configuration intact while launching Emacs with another set of options.

Create the test init.el file

Have a directory that is unrelated to your regular Emacs configuration. Then write the init.el inside of it.

Because I do this frequently, I prefer to use the standard Linux path /tmp/. Its files get deleted as soon as I switch off the computer, which is exactly what I want in this case.

As such, if there is a bug with, say, the modus-themes, I will work with this file path /tmp/modus-themes/init.el.

But the exact location of the directory does not matter, so choose what makes sense to you.

Write the minimum necessary code

In that init file, include only the code that is needed to reproduce the bug.

Since you want to have the package installed, it makes sense to write a use-package declaration for it. Include the :ensure t directive as it instructs the built-in package manager to install the package if it is not already available.

;; Contents of the init.el...
(use-package modus-themes
  :ensure t
  :config
  (setq modus-themes-common-palette-overrides
        '((fringe unspecified)
          (border-mode-line-active unspecified)
          (border-mode-line-inactive unspecified)))
  (setq modus-vivendi-palette-overrides
        '((bg-main "#1e1f22")
          (fg-main "#bcbec4")))
  (load-theme 'modus-vivendi t))

Install from source, if necessary

If you are using an alternative to package.el like straight or elpaca, then the aforementioned :ensure t will likely not suffice: you need to build the package from source. To this end, Emacs has the function package-vc-install. Some of my recent packages have sample code that relies on this approach. For instance:

(use-package gnome-accent-theme-switcher
  :demand t
  :init
  ;; Then upgrade it with the command `package-vc-upgrade' or `package-vc-upgrade-all'.
  (unless (package-installed-p 'gnome-accent-theme-switcher)
    (package-vc-install "https://github.com/protesilaos/gnome-accent-theme-switcher.git"))
  :bind
  (("<f5>" . gnome-accent-theme-switcher-toggle-mode)
   ("C-<f5>" . gnome-accent-theme-switcher-change-accent))
  :config
  (gnome-accent-theme-switcher-mode 1))

In the above snippet package-vc-install will pull the latest commit from the main branch, though it can even get a specific commit. Read its documentation with M-x describe-function.

What matters is that you fetch the version which you are running in your personaly configuration.

Launch Emacs with this configuration

From the command-line, run something like the following:

emacs --init-directory=/tmp/test-emacs/

This will launch a new instance of Emacs. The use-package you placed there will do the work to install the package. After that you are ready to reproduce the bug in this clean setup.

Write down all the steps

To help the maintainer identify the source of the trouble, keep a record of all the steps you followed. Some bugs show up when the package is loaded, but others are triggered only after a specific action is performed.

Normally, Emacs will pop up a *Backtrace* buffer when it encounters an error. Copy its contents and send them to the maintainer, together with the init.el you used, and the list of the steps you followed.

Sometimes you just need to re-install the package

It sometimes happens that you install a package and it is completely broken. Although this looks bad, it may not even be a bug, but an issue with the old bytecode you had on your system from the previous version of the package.

Do M-x package-delete, select the package, restart Emacs, and then M-x package-install to install the package anew. If everything works, then the problem is gone and you do not need to tell the maintainer about it.

Make it easier for maintainers to help you

With this knowledge, you can provide high quality bug reports for the packages you rely on. Good luck!

On Thursday, the 12th of March 2026, at 6 PM United Kingdom time (GMT) I will give a talk titled Computing in freedom with GNU Emacs. My intention is to introduce Emacs to a wide audience. Participation is open to everyone.

I will post a reminder as we get closer to the date of the event. Looking forward to it!

The package supports the universities of Oxford and Cambridge out-of-the-box, though users can define their own institutions. I have two institutions there to provide concrete examples. I am happy to add more, but the idea is for users to maintain their own data.

Below I show a complete example using data for a school in Austria.

Write the calendar data

To make this work, you first need to specify the data. This has the same structure as institution-calendar-oxford-university-dates and thus passes the test of institution-calendar-valid-data-p. Look at the code for Oxford to get an idea. Here is a sample:

(defvar my-austrian-school-dates
  '((2025 (wintersemester ( 9  8 2025) ( 2  6 2026))
          (sommersemester ( 2 16 2026) ( 7 10 2026)))))

This is an Austrian school that has two terms for the academic year starting in 2025: wintersemester and sommersemester. The symbols for those terms can be anything. Internally, the package uses the first letter to form the week indicator, followed by the number of the week within the given term.

Each term defines a start date and an end date as a list of integers of the form (MONTH DAY YEAR). I picked a form that is consistent with the way calendar.el represents the date, otherwise I would have used a different standard.

Register your institution

The variable institution-calendar-user-entities contains all user-defined institutions and their corresponding calendar data. Each entry is a cons cell of the form (ENTITY . CALENDAR-DATA), where ENTITY is an arbitrary symbol and CALENDAR-DATA is the symbol of a variable that holds the data, as shown in the previous section.

Here is how we can add to this list:

(add-to-list 'institution-calendar-user-entities (cons 'austrian-school 'my-austrian-school-dates))

In this example, I am calling the newly registered institution austrian-school, which is how I can refer to it elsewhere. I am associating this austrian-school with the calendar data of the variable my-austrian-school-dates.

Make the institution-calendar-mode work for your institution

With the aforementioned in place, the user option institution-calendar-entity can be set to the value of austrian-school:

(setopt institution-calendar-entity 'austrian-school)

If the institution-calendar-mode is enabled, then the regular calendar command will display week indicators for this school. This is good if you only need one calendar. But if you work with many institutions and thus need to switch between their calendars, then ignore this step and move to the next one. Or ignore it anyway if you prefer to keep the M-x calendar intact.

Define a custom command for your institution

The macro institution-calendar-define-convenience-command makes it trivial to define a command that produces a calendar buffer for the given institution. This is like M-x calendar with the minor mode institution-calendar-mode enabled, except it does not alter the output of the calendar—so you can use them both (or, anyhow, use as many as the institutions you care about).

;; This defines the command `institution-calendar-austrian-school'.
;; Call `institution-calendar-austrian-school' with M-x or bind it to a key.
(institution-calendar-define-convenience-command austrian-school)

Once you evaluate this macro call, you will get the command institution-calendar-austrian-school. Use that to produce a calendar that works with the austrian-school in particular. If you are curious, M-x institution-calendar-oxford-university will still do the right thing for the University of Oxford. Same for the command institution-calendar-cambridge-university.

Use an intermonth header

The user option institution-calendar-include-intermonth-header adds a header above the week numbers. By default, this only works with the universities of Oxford and Cambridge. Though you can extend the package to support your institution by adding to the value of the variable institution-calendar-intermonth-headers. Thus:

(add-to-list 'institution-calendar-intermonth-headers (cons 'austrian-school "AU"))

You can skip this step if you do not plan to display the intermonth header. Those are not shown by default.

Putting it all together

This is how your configuration of the institution-calendar may look like:

(use-package institution-calendar
  :ensure nil ; not in a package archive
  :init
  ;; Install it from source.
  ;; Then upgrade it with the command `package-vc-upgrade' or `package-vc-upgrade-all'.
  (unless (package-installed-p 'institution-calendar)
    (package-vc-install "https://github.com/protesilaos/institution-calendar.git"))
  :config
  (defvar my-austrian-school-dates
    '((2025 (wintersemester ( 9  8 2025) ( 2  6 2026))
            (sommersemester ( 2 16 2026) ( 7 10 2026)))))

  (add-to-list 'institution-calendar-user-entities (cons 'austrian-school 'my-austrian-school-dates))

  ;; This defines the command `institution-calendar-austrian-school'.
  ;; Call `institution-calendar-austrian-school' with M-x or bind it to a key.
  (institution-calendar-define-convenience-command austrian-school)

  (setopt institution-calendar-include-extra-week-numbers t)
  (setopt institution-calendar-include-intermonth-header nil)

  ;; These are optional, if you want `M-x calendar' to work for your institution.
  (setopt institution-calendar-entity 'austrian-school)

  (institution-calendar-mode 1))

Sources

• Git repository: https://github.com/protesilaos/institution-calendar
• Screenshot: https://protesilaos.com/codelog/2026-02-11-emacs-institution-calendar/
• Backronyms: Interestingly Nothing Serving Teachers Implement Term Utilities Took Inspiration from Oxford Novices… calendar; Institution … Cambridge Added Lent Entry Notwithstanding Dates Already Recorded.

In this short video I demonstate a new package for GNU Emacs that synchronises the Emacs theme with the GNOME settings for accent color and light/dark mode. Git repository here: https://github.com/protesilaos/gnome-accent-theme-switcher.

The idea is that hl-line-mode cannot work equally well for contexts with competing priorities: (i) line selection, or (ii) simple line highlight. In the former case, the current line needs to be made prominent because it carries a specific meaning of some significance in the given context: the user has to select a line. Whereas in the latter case, the primary mode of interaction does not revolve around the line highlight itself: it may be because the focus is on editing text or reading through the buffer’s contents, so the current line highlight is more of a reminder of the point’s location on the vertical axis.

• Package name (GNU ELPA): lin
• Official manual: https://protesilaos.com/emacs/lin
• Change log: https://protesilaos.com/emacs/lin-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/lin
  • GitLab: https://gitlab.com/protesilaos/lin
• Backronym: LIN Is Noticeable.

Below are the release notes

Version 2.0.0 on 2026-02-12

This is the first tagged release since 2024-08-05. The package is in a stable state: it does everything it is meant to. This version makes some small refinements, mostly in how parts of the code are written. Though there also are some nice user-facing changes:

• The lin-gnome-accent-color-mode synchronises the accent colour of the GNOME desktop environment with Lin’ own lin-face. This happens live, so any buffers that are already using the lin-mode (directly or via lin-global-mode) will get the updated colour.

• The user option lin-gnome-accent-color-override-foreground controls whether the faces that correspond to GNOME accent colours should override the underlying text colour or not. This is useful for improved colour contrast. The default is to not override the foreground. Setting lin-gnome-accent-color-override-foreground to non-nil changes that so, for example, the lin-face will be set to lin-red-override-fg instead of lin-red (of course, faces can be modified by users/themes to override the foreground anyway, so this is about the default behaviour).

• New faces to style the current line when lin-mode is enabled include lin-purple, lin-orange, and lin-slate. Those do not override the underlying foreground colours by default. Whereas lin-purple-override-fg, lin-orange-override-fg, and lin-slate-override-fg apply their background while also setting the foreground (remember that you always control which face to use by changing the user option lin-face).

• The lin-global-mode skips all private buffers. These are buffers that users normally do not interact with directly. Their names are prefixed with a space and, by default, are hidden from the view of switch-to-buffer and related commands.

• The default value of the user option lin-mode-hooks now includes the world-clock-mode-hook and xref--xref-buffer-mode-hook. The former relates to the command world-clock, while the latter is used by any command that produces Grep-like results via the built-in Xref infrastructure (for example, my Denote package does that for a few of its commands). The lin-mode-hooks is a list of hooks for major modes that should use the Lin style for the selection line highlight.

This is about a new package of mine: institution-calendar. It is not going to be available on GNU ELPA. Users will have to install it from source (code for this is further below). The reason is that the predecossor to this package, oxford-calendar, was not accepted:

• https://lists.gnu.org/archive/html/emacs-devel/2026-01/msg00337.html.
• https://lists.gnu.org/archive/html/emacs-devel/2026-01/msg00401.html.

I will consider my options going forward, with whatever that means for all my packages.

Overview

The institution-calendar package augments the M-x calendar buffer to include indicators about the applicable term. Each term has week numbers, which are displayed on the side of the regular calendar data.

The user option institution-calendar-entity specifies which institution’s data to use. Currently, the value can be either oxford-university or cambridge-university. Contact me and I will add support for your institution.

Each term shows the week numbers it formally defines. For example, the University of Oxford has three terms of 8 weeks each. When the user option institution-calendar-include-extra-week-numbers is set to a non-nil value, then an additional two weeks are added: week 0 for one week before the term starts and an extra number after the term ends. This is useful for scheduling purposes, such as to arrange meetings in preparation of the work ahead or to report on what happened.

The user option institution-calendar-include-intermonth-header writes text above the institution’s week indicators. This makes it a bit easier to tell them apart from the regular calendar data.

Showing the calendar

Enable the minor mode institution-calendar-mode to make all future calls to M-x calendar use the relevant institution data.

If you do not want to affect the M-x calendar output, then use the command institution-calendar: it is functionally equivalent to having the aforementioned minor mode enabled, except it has no permanent effect on M-x calendar—that will keep its original appearance.

If, for whatever reason, you need to check the calendar of a specific institution, then do M-x institution-calendar-cambridge-university or M-x institution-calendar-oxford-university (more such commands will be available to match any other institutions that this package will support).

Installation and configuration

(use-package institution-calendar
  :ensure nil ; not in a package archive
  :init
  (unless (package-installed-p 'institution-calendar)
    (package-vc-install "https://github.com/protesilaos/institution-calendar.git"))
  :commands
  (institution-calendar
   institution-calendar-cambridge-university
   institution-calendar-oxford-university)
  :config
  (setopt institution-calendar-entity 'oxford-university)
  (setopt institution-calendar-include-extra-week-numbers t)
  (setopt institution-calendar-include-intermonth-header nil)

  ;; If you want to permanently change what M-x calendar shows, enable
  ;; this mode.  Otherwise, use the relevant command from the
  ;; :commands listed above.
  (institution-calendar-mode 1))

Sources

• Git repository: https://github.com/protesilaos/institution-calendar
• Screenshot: https://protesilaos.com/codelog/2026-01-09-emacs-oxford-calendar-package/
• Backronyms: Interestingly Nothing Serving Teachers Implement Term Utilities Took Inspiration from Oxford Novices… calendar; Institution … Cambridge Added Lent Entry Notwithstanding Dates Already Recorded (yes, I always have a lot of fun writing these!).

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.0.0 on 2026-02-09

Two new themes

doric-jade is a light theme with a predominantly green feel.

doric-copper is a dark theme with orange, magenta, and cyan colours.

I have update all screenshots: https://protesilaos.com/emacs/doric-themes-pictures.

Revised styles for Org TODO and DONE

The relevant faces now use a colour-coding scheme where TODO states are rendered in red while DONE are green.

This is done to ensure cross-theme consistency. Those faces communicate a certain state and, therefore, it is better to not have to relearn which colour means what while switching between the Doric themes.

Org ~code~ faces stand out more

This is done to differentiate them from =verbatim=. It is especially important for users who choose to hide the markup with the user option org-hide-emphasis-markers (I used to do that but realised that the ambiguity was a problem in many cases, because ~code~ and =verbatim= have different semantics in some exported formats).

Refinements to all Org heading or heading-like faces

This covers the regular Org headings as well as anything that performs the same function, such as in the Org agenda buffer.

All regular headings use the main foreground value. The document title and the Org agenda equivalent of that are rendered in an accent colour for greater effect.

Combined with the aforementioned revision of the TODO and DONE states, Org buffers are easier to read and work with.

Tweaks for the Org agenda faces

The faces that communicate the current time and applicable filters are made more intense. The idea is to spot them more quickly.

Faces that pertain to diary or diary-style events no longer use italics to avoid exaggerations.

Blocked tasks are easier to spot.

The applicable query in the structure header is made more prominent.

Overall, Org agenda buffers should be easier to scan.

More obvious style for Org exporting

The active/available keys in the Org export dispatcher use more intense colours and have greater padding around them. This is what I also do with the Modus themes (and all derivatives) to improve the legibility of those keys.

Magit branch and author faces are redone

The authors in log views and elsewhere have a distinct colour to stand out a bit more. Branches use consistent typography, while the current branch stands out more than the others.

New colours for transient faces with background values

Enabled and disabled keys use a green-red coding scheme.

Active values and arguments have a style that is the same across themes for the same reason as Org TODO and DONE.

Transient headings use the main foreground colour to not draw more attention than they need to.

Git commit faces follow the aforementioned patterns

Those are seen when writing a commit message in Magit.

VC logs better differentiate the commit author

The relevant face uses a distinct foreground. It no longer applies a bold weight, as that had the effect of making the buffers much busier than necessary.

Colour-coded styles for Dired marks

Items that are marked for selection are rendered in a green style, while those marked for deletion are red.

This is done for cross-theme consistency, so that users do not have to think twice before performing the relevant operations.

The doric-themes-with-colors macro for advanced users

This macro is effectively the same as a let for binding the colours of the active Doric theme. Advanced users can rely on this macro to write functions that, for example, set the theme-specific red colour value of a given face.

Miscellaneous

Symlinks in Dired buffers are easier to spot. Same for visited links in Info buffers.

Org definitions no longer override the foreground of any other face present in them. Same for the notmuch header in view buffers.

doric-jade is a light theme with an emphais on green. doric-copper is a dark theme with mostly orange accents and hints of patina. Both themes retain the Doric quality of using few colours while relying on typography to establish rhythm and structure.

Below are their samples.

[ Or just check all the pictures: https://protesilaos.com/emacs/doric-themes-pictures. ]

doric-jade

doric-copper

Coming in doric-themes version 0.7.0

Both doric-jade and doric-copper are in-development. I have already worked on their finer point, but may still make some tweaks before publishing them as part of the next stable version of the doric-themes.

About the Doric themes

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. Legibility is still high.

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.

• Package name (GNU ELPA): beframe
• Official manual: https://protesilaos.com/emacs/beframe
• Change log: https://protesilaos.com/emacs/beframe-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/beframe
  • GitLab: https://gitlab.com/protesilaos/beframe
• Video demo: https://protesilaos.com/codelog/2023-02-28-emacs-beframe-demo/
• Backronym: Buffers Encapsulated in Frames Realise Advanced Management of Emacs.

Below are the release notes

Version 1.5.0 on 2026-02-04

This version fixes two bugs and makes other minor tweaks.

The first bug pertains to the performance of the command beframe-switch-buffer or the command switch-to-buffer when beframe-mode is enabled: they were really slow when the list of buffers was long. Now they are always fast. Thanks to Alexandre Rousseau for reporting the problem in issue 17: https://github.com/protesilaos/beframe/issues/17.

The second bug is more subtle. It is about persisting the completion metadata category value in all prompts that read a buffer, when beframe-mode is enabled. This change means that users who configure the user option completion-category-overrides will not get the expected results in buffer prompts affected by Beframe.

Thanks to Stefan Monnier for commenting on the initial implementation, specifically telling me that let binding the metadata can affect nested minibuffers, which we do not want. This was done on the emacs-devel mailing list: https://lists.gnu.org/archive/html/emacs-devel/2025-12/msg00264.html.

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

Below are the release notes.

Version 2.1.0 on 2026-01-27

This version introduces two carefully designed, legible and colourful themes: ef-orange (light) and ef-fig (dark). Both draw inspiration from the fruits they are name after.

The convenience commands ef-themes-select-dark and ef-themes-select-light use the minibuffer to select+load an Ef theme that is either dark or light, respectively. The more general command is ef-themes-select.

All screen shots of the themes are updated to reflect their current status: https://protesilaos.com/emacs/ef-themes-pictures.

Remember that since version 2.0.0 the ef-themes are built on top of my modus-themes. This means that most of the changes happen to Modus and are inherited by Ef.

• Package name (GNU ELPA): tmr
• Official manual: https://protesilaos.com/emacs/tmr
• Change log: https://protesilaos.com/emacs/tmr-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/tmr
  • GitLab: https://gitlab.com/protesilaos/tmr
• Video demonstration: https://protesilaos.com/codelog/2026-01-19-emacs-timers-tmr-demo/
• Backronym: TMR May Ring; Timer Must Run.

Below are the release notes.

Version 1.3.0 on 2026-01-25

This version adds some user options and new features to an already stable package.

Timers can be paused

The command tmr-toggle-pause will prompt for a running timer and pause it.

Users who have something like the following in their configuration, have access to tmr-toggle-pause under the P key:

;; All TMR commands are behind this prefix key.  So `tmr-toggle-pause' is C-c t P.
(define-key global-map (kbd "C-c t") #'tmr-prefix-map)

In the buffer produced by the command tmr-tabulated-view the pause functionality applies to the timer at point. The tmr-toggle-pause is invoked with the P key.

An extra column in the tabulated view shows whether a timer is paused or not. Here is an example:

Start      End        Duration   Remaining  Paused?  Acknowledge?   Description

08:49:41   09:19:46   30m        29m 17s    Yes                     Work on TMR for 30 minutes
08:49:31   08:54:31   5m         3m 53s                             Prepare tea
08:49:21   08:59:21   10m        8m 42s              Yes            Edit the description with this one instead

Configure the confirmation text for acknowledgements

When a timer is set to be acknowledged (i.e. the user must confirm that they saw it elapse) it prompts for confirmation. The default input text that confirms the acknowledgement is ack. This is now subject to configuration via the user option tmr-acknowledge-timer-text.

Change how frequently the tabulated list is refreshed

The buffer produced by tmr-tabulated-view is set to automatically refresh every 5 seconds by default. In previous versions this was every 1 second. The new user option tmr-tabulated-refresh-interval can be set to a number of seconds or nil. In the latter case, the automatic refresh is disabled.

Removed the long-obsolete tmr-tabulated.el

Its code was merged into tmr.el on 2024-10-30 and all it was doing thenceforth is issue a warning to those who would require the tmr-tabulated feature. Now (require 'tmr-tabulated) produces an error.

In this ~15-minute video I demonstrate a package of mine called tmr (pronounced as an acronym or as “timer”). It uses a simple notation to set the duration of a timer at the minibuffer prompt. Once the timer elapses, Emacs shows a notification. The desktop environment will also include one, as well as an audio alert (those are configurable). Timers can optionally have a description. They may also be listed in a tabulated/grid view, which makes it easier to work with them (to edit their description, reschedule them, etc.). Running timers may also be displayed on the mode line.

Sample configuration

(use-package tmr
  :ensure t
  :config
  (define-key global-map (kbd "C-c t") #'tmr-prefix-map)
  (setq tmr-sound-file "/usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga"
        tmr-notification-urgency 'normal
        tmr-description-list 'tmr-description-history))

TMR sources

• Package name (GNU ELPA): tmr
• Official manual: https://protesilaos.com/emacs/tmr
• Change log: https://protesilaos.com/emacs/tmr-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/tmr
  • GitLab: https://gitlab.com/protesilaos/tmr
• Backronym: TMR May Ring; Timer Must Run.

• Package name (GNU ELPA): notmuch-indicator
• Official manual: https://protesilaos.com/emacs/notmuch-indicator
• Change log: https://protesilaos.com/emacs/notmuch-indicator-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/notmuch-indicator
  • GitLab: https://gitlab.com/protesilaos/notmuch-indicator
• Backronym: notmuch-… Interested in Neatly Displayed Indicators that Count Any Terms Ordinarily Requested.

Below are the release notes.

1.3.0 on 2026-01-18

This version adds quality-of-life refinements to a stable package.

The notmuch-indicator-mode sets up the notmuch-after-tag-hook

The indicator will be updated whenever a message’s tags change. This way users do not need to rely on the timer-based method that we have always had.

The notmuch-indicator-refresh-count can be set to nil

Doing so has the effect of disabling the timer-based refresh of the indicator. It will now be updated only when some event happens, such as with the aforementioned change to tags or after the invocation of any of the commands listed in the user option notmuch-indicator-force-refresh-commands.

More configuration file paths

When checking for the notmuch configuration file, we now also consider these two filesystem paths:

• $HOME/.config/notmuch/$NOTMUCH_PROFILE/config
• $HOME/.config/notmuch/default/config

Thanks to Yejun Su for the contribution in pull request 6: https://github.com/protesilaos/notmuch-indicator/pull/6.

The change is small, meaning that Yejun Su does not need to assign copyright to the Free Software Foundation.

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 0.6.0 on 2026-01-17

This version adds support for more packages, while it revises some of the faces that were already covered.

Enhanced completion interface

The minibuffer prompt used by the command doric-themes-select now groups themes by their light or dark type. The current theme is at the top.

Avy highlights are easier to spot

The highlights generated by the various commands of the avy package now have a slightly more intense background+foreground colour combination. It should be easier to spot and to differentiate from other highlights such as that of hl-line-mode and the mouse hover effect over links.

Support for all the tmr faces

My tmr package styles timers in its grid/tabulated interface as well as on the mode line. All these now get colours that come directly from the active Doric theme. Before, the colours were defined only in the tmr source code: they were “okay” (because they are based on my modus-themes) but not stylistically optimal.

Support for ruler-mode

The built-in ruler-mode draws a ruler at the top of the current buffer. All of its faces now use appropriate colours.

Trailing spaces have a more refined colour

All packages that have a face that is about highlighting trailing spaces now get a red colour value that is more appropriate for each Doric theme.

SHR buffers can use proportionately spaced fonts

I removed an override for the built-in shr-text face, which was making the nov package display its buffers in a monospaced font.

Thanks to Marcus Kammer for telling that nov-mode buffers were not proportionately spaced by default. This was done in issue 23: https://github.com/protesilaos/doric-themes/issues/23.

The oxford-calendar is a small package that is of interest to students, academics, and staff of the University of Oxford. It augments the M-x calendar buffer with indicators that show the applicable term (Michaelmas, Hilary, Trinity) and week number.

To show the indicators, enable the oxford-calendar-mode. By default, it includes the extra weeks 0 and 9 at the boundaries of each term. The idea is to make things easier for planning purposes. Remove those extra weeks by setting oxford-calendar-include-extra-week-numbers to nil.

To include a heading above the term indicators, set the user option oxford-calendar-include-intermonth-header to a non-nil value.

I will now do the work to include the package on the GNU ELPA archive.

Sources

• Package name (GNU ELPA): oxford-calendar (!!! COMING SOON)
• Git repository: https://github.com/protesilaos/oxford-calendar
• Backronym: Overtly Xenial Feature Orders Relevant Dates … Calendar.

These substitutions are meant to be as quick as possible and, as such, differ from the standard query-replace (which I still use when necessary). The provided commands prompt for substitute text and perform the substitution outright, without moving the point. The target is the symbol/word at point or the text corresponding to the currently marked region. All matches in the given scope are highlighted by default.

• Package name (GNU ELPA): substitute
• Official manual: https://protesilaos.com/emacs/substitute
• Git repositories:
  • GitHub: https://github.com/protesilaos/substitute
  • GitLab: https://gitlab.com/protesilaos/substitute
• Video demo: https://protesilaos.com/codelog/2023-01-16-emacs-substitute-package-demo/
• Backronym: Substitutions Uniformly Beget Standardisation for Text Invariably Transfigured Unto This Entry.

Below are the release notes.

Version 0.5.0 on 2026-01-05

This is a small release that fixes a bug and adds a relevant user option.

The bug pertained to the scope of the substitution when buffer narrowing was in effect. All commands would ignore narrowing and also fail to properly clear the highlights they apply (highlights are transiently in effect to show what the target of the substitution is while the minibuffer is waiting for user input).

Now all commands do the right thing with respect to buffer narrowing. Though their exact behaviour depends on the value of the new user option substitute-ignore-narrowing:

• When the value of substitute-ignore-narrowing is non-nil, then substitutions apply to the actual scope of the given command. For example, substitute-target-in-buffer will cover the whole buffer from the absolute minimum position to the absolute maximum position even if narrowing is in effect.

• When the value of substitute-ignore-narrowing is nil, then substitutions apply to their scope subject to the boundaries of the narrowed buffer. For example, substitute-target-in-buffer will understand as “whole buffer” the region between the minimum and maximum positions of the narrowed buffer.

Users can write small convenience commands that do either of those, depending on preference. For example:

(defun my-substitute-target-in-buffer-with-narrowing ()
  "Call `substitute-target-in-buffer' with `substitute-ignore-narrowing' as `nil'."
  (let ((substitute-ignore-narrowing nil))
    (call-interactively 'substitute-target-in-buffer)))

(defun my-substitute-target-in-buffer-without-narrowing ()
  "Call `substitute-target-in-buffer' with `substitute-ignore-narrowing' as non-`nil'."
  (let ((substitute-ignore-narrowing t))
    (call-interactively 'substitute-target-in-buffer)))

Thanks to zauberen for reporting the bug in issue 11: https://github.com/protesilaos/substitute/issues/11.

Sample pictures are available below. Check all the items here: https://protesilaos.com/emacs/ef-themes-pictures. Always click to enlarge the image for best results.

ef-orange

ef-fig

Coming in version 2.1.0 (next stable release)

Both themes are done. Though there may still be some minor refinements. They will be widely available as part of the next stable version of the ef-themes package (maybe end of January 2026).

Remember that since version 2.0.0, the ef-themes are built on top of my modus-themes. This means that they are highly customisable and support a wide range of packages and face groups.

Enjoy!

The ef-themes are a collection of light and dark themes for GNU Emacs that provide colourful (“pretty”) yet legible options for users who want something with a bit more flair than the modus-themes (also designed by me).

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

• Package name (GNU ELPA): modus-themes (also built into Emacs 28+)
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

5.2.0 on 2025-12-31

This version fixes some bugs, adds a new feature for those who want to derive a theme from Modus, and makes other small quality-of-life refinements.

The modus-themes-with-colors should work at all times

In the transition to version 5.0.0, I inadvertently introduced regressions to the behaviour of the modus-themes-with-colors macro. This macro let binds the current theme’s palette around arbitrary Elisp expressions, which allows users to access the named colours therein. In versions 5.0.0 and 5.1.0 the macro could not read variables defined outside its scope. Users needed to write an eval around it, which I did not like. Now the macro should not require such workarounds: it basically is a let that should work as expected everywhere.

This was fixed over a series of Git commits related to issue 170: https://github.com/protesilaos/modus-themes/issues/170. Thanks to Alexandr Semenov and realazy for reporting the problems and testing my revisions.

The modus-themes-generate-palette function to quickly get a palette

Users or package developers who want to create a theme on top of Modus can now get a kickstart by defining their palette with the help of the new modus-themes-generate-palette function. This function is meant to return a complete palette, given a list of basic colours. Users can thus experiment with their new theme while knowing that what they got contains all the definitions; definitions that they may then modify further (e.g. to define different semantic mappings than the defaults such as, for example, to have (fg-heading-1 red-warmer) instead of what originally is (fg-heading-1 fg-main)).

I have written extensive documentation in the manual, which includes a complete example of a Solarized theme that is built on top of Modus. If you have any questions, you are welcome to contact me.

Convenience commands to select only dark or light themes

The commands modus-themes-select-dark and modus-themes-select-light use minibuffer completion to load a theme. The completion candidates are filtered to only dark or light themes, respectively.

This is effectively the same as calling the command modus-themes-select with a prefix argument (C-u by default).

Remember that we also have the commands modus-themes-load-random, modus-themes-load-random-dark, and modus-themes-load-random-light. Otherwise use the command modus-themes-rotate.

Improved prompt for theme selection

The minibuffer prompt used by the various Modus commands to select a theme now has a grouping function in place: it shows the current theme at the top and then all other themes grouped by their dark or light background. This makes it easier to find a relevant theme, especially if lots of them are present, such as when modus-themes-include-derivatives-mode is enabled and relevant packages/themes are available (e.g. my ef-themes and standard-themes).

Semantic colours for transient.el (e.g. in Magit)

The transient.el concept of “semantic colours” is now supported. This is used by default in Magit to denote the different types of keys, such as those that exit the transient, keep it active, move to another transient, and the like. Users who prefer the old style where all key bindings looked the same must customise the user option transient-semantic-coloring.

Note that the deuteranopia- and tritanopia- optimised themes adapt gracefully to such “semantics”, owning to relevant internal refinements I made. Those themes cannot rely on the full colour spectrum to communicate such nuances.

All hl-todo-mode faces use a bold weight if appropriate

When the user option modus-themes-bold-constructs is set to a non-nil value, then all keywords that hl-todo-mode highlights will be rendered in a bold weight (technically, they inherit the bold face). This is how we were doing it before until I undid it by mistake. Thanks to Dominik Schrempf for reporting the bug in issue 177: https://github.com/protesilaos/modus-themes/issues/177.

Theme-sensitive colours for Gnus mail groups

The Gnus mail groups no longer have hardcoded colour values. They will look different depending on the current Modus theme.

Faces that set a :box attribute handle unspecified colours

I updated all faces that use a :box attribute to account for the scenario of a user writing palette overrides that unset the relevant colour. Thanks to JD Smith for reporting a bug along those lines in issue 9 of my standard-themes repository (they are derived from the modus-themes, hence the changes here): https://github.com/protesilaos/standard-themes/issues/9.

The calendar-today and org-date-selected faces are disambiguated

These two faces are no longer using the same styles. This is because they can appear in the same buffer. Thanks to Rudolf Adamkovič for discussing this with me in the context of the same change for my doric-themes (issue 20 in doric-themes.git): https://github.com/protesilaos/doric-themes/issues/20.

The Modus “current theme” respects multiple enabled themes

The Modus concept of “current theme” respects the user’s choice for multiple themes loaded at once. It will return the first Modus theme even if it is not at the front of the list.

[ Emacs will load multiple themes by default, which leads to awkward colour combinations, unless you know what you are doing—as such all the Modus commands that load a theme will disable all others, subject to the user option modus-themes-disable-other-themes. ]

Thanks to Pierre Téchoueyres for reporting the scenario where multiple other themes are loaded on top of a Modus theme. This was done in issue 182: https://github.com/protesilaos/modus-themes/issues/182.

Also thanks to Pierre for covering another snippet that I had missed. This was done in pull request 184: https://github.com/protesilaos/modus-themes/pull/184.

Pierre has assigned copyright to the Free Software Foundation.

Fixed symbol of inherited AUCTeX face

There was a typo which caused an error. Thanks to Rudolf Adamkovič for the patch and also for providing a relevant unit test. This was done in pull request 188: https://github.com/protesilaos/modus-themes/pull/188.

Rudolf has assigned copyright to the Free Software Foundation.

Miscellaneous

• Thanks to Basil L. Contovounesios for simplifying a couple of expressions. This was done in pull request 190: https://github.com/protesilaos/modus-themes/pull/190. Basil has assigned copyright to the Free Software Foundation.

• The faces of the built-in completion-preview-mode are now supported. Thanks to Kevin Fleming for asking me about this in issue 178: https://github.com/protesilaos/modus-themes/issues/178.

• Several faces that had a strike-through effect when they did not really need it are revised to use a wavy underline instead. The idea is to let the text be readable at all times, regardless of the effective font family. With the strike-through effect, some fonts completely obscure the underlying text.Thanks to Morgan Willcock for discussing with me the use of the strike-through style in issue 169: https://github.com/protesilaos/modus-themes/issues/169.

• All symbol-overlay faces are unique, fixing a mistake I had done before.

• The org-dispatcher-highlight, which is used to highlight the keys of the Org export interface, now uses the appropriate foreground colour and is always rendered in a bold weight.

• The org-habit faces no longer call the function readable-foreground-color. This is because that function does not work if the theme is loaded via the early-init.el. Thanks to Gaston Cabotin for reporting the problem in issue 174: https://github.com/protesilaos/modus-themes/issues/174.

• The gnus-button, which Gnus uses in all sorts of places to mark some text as clickable, is styled with a less intense underline and will no longer follow the style of links, including possible palette overrides. This way, Gnus article buffers will not have visual noise. Thanks to Morgan Willcock for discussing this with me in issue 140: https://github.com/protesilaos/modus-themes/issues/140.

I produced both of those from the source Org file. Here are the steps for posterity:

• From the elispelem.org use the Org export mechanism to generate an Info manual (by default: C-c C-e i i).
• This will generate a .texi file, which is then used as the source for the .info file.
• From the command-line do texi2any --epub elispelem.texi to get the EPUB file.
• For the PDF, install the dependencies with something like sudo apt install texlive.
• Finally, run texi2any --pdf elispelem.texi.

• Sorting: Files are sorted by last modified.
• Grouping: Files are organised by type (remember that the Denote file-naming scheme can be applied to any file—I do so for videos, pictures, PDFs, …).
• Affixating: Files have their date identifier as a prefix and their keywords as a suffix.

The file prompt is used when linking to a file, like with the denote-link command, or when calling the command denote-open-or-create (and related).

The old style

File names were presented as relative paths without further modifications. This style relies on the Denote file-naming scheme to narrow down the list by typing. For example 202512 finds all files with that in their identifier (i.e. their creation date by default), _emacs finds all files with the given keyword, and -word with that word in their title.

The new style

The file names are still the same behind the scenes, but their data is presented in a more readable way. There is no loss of functionality, meaning that users can still match _keyword, -title, and the like, per the Denote file-naming scheme.

Part of development

I might make further changes, though the idea is clear. Expect to get similar features in my other packages, such as consult-denote, denote-sequence, denote-journal.

For the denote-sequence package, in particular, the file prompt it uses shows sequences instead of identifiers as the prefix of each file. This is because that prompt is relevant for tasks where the user needs to know the exact sequence, such as when they create a note that is the child of another.

Power users can study the functions stored in the variable denote-file-prompt-extra-metadata (same idea for the denote-sequence package: denote-sequence-file-prompt-extra-metadata).

About Denote

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

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

This release introduces some nice refinements and fixes a couple of subtle bugs.

Subtle mode and header line

The new user option spacious-padding-subtle-frame-lines supersedes the ~spacious-padding-subtle-mode-line. It does the same thing, namely, of making the mode lines use only a thin line instead of a background. Though it extends this feature to header lines as well.

The documentation string of spacious-padding-subtle-frame-lines describes the technicalities and includes examples. In short, we can associate a keyword with either a face that has a foreground color or a color value directly. For the convenience of the user, the package also defines the faces spacious-padding-line-active and spacious-padding-line-inactive. Here is a sample configuration:

;; Read the doc string of `spacious-padding-subtle-mode-line' as it
;; is very flexible.  Here we make the mode lines be a single
;; overline, while header lines have an underline.
(setq spacious-padding-subtle-frame-lines
      '( :mode-line-active spacious-padding-line-active
         :mode-line-inactive spacious-padding-line-inactive
         :header-line-active spacious-padding-line-active
         :header-line-inactive spacious-padding-line-inactive))

In the future, we might decide that other elements can benefit from this style.

The header line underline is spaced further away from the text

As noted above, when spacious-padding-subtle-frame-lines is configured to cover header lines, those will be drawn with an underline. This will not intersect with the text of the header line.

Normally, underlines cut through letters that descend below the baseline, such as the letters g and y. We choose to avoid that because it makes for a cleaner interface (though I personally think it is not a good style for paragraph text, because of the rivers of negative space it introduces).

This specific design is available for Emacs version 29 or higher. Users of Emacs 28 must set x-underline-at-descent-line to a non-nil value. Though note that this has a global effect: we cannot limit it to a single face.

Thanks to Steven Allen for covering this in pull request 37: https://github.com/protesilaos/spacious-padding/pull/37. Steven has assigned copyright to the Free Software Foundation.

The spacious-padding-widths can affect Custom buttons

This is about the buttons we find in buffers of the Custom system. For example, we get such a buffer after we do M-x customize.

The relevant keyword is :custom-button-width. It is set to a number of spaces for padding. Here is the default value and, as always, the documentation cover the details:

(setq spacious-padding-widths
      '( :internal-border-width 15
         :header-line-width 4
         :mode-line-width 6
         :custom-button-width 3 ; the new one
         :tab-width 4
         :right-divider-width 30
         :scroll-bar-width 8
         :fringe-width 8))

Fixes for the Emacs daemon

There were reports about incorrect face specifications that could happen when Emacs was started as a daemon process. I made the relevant changes. Also thanks to kaibagley for covering a line I had missed. This was done in pull request 43: https://github.com/protesilaos/spacious-padding/pull/43.

Related threads:

• Issue 35, as reported by Chinmay Dalal: https://github.com/protesilaos/spacious-padding/issues/35.
• Issue 41, as reported by zealotrush: https://github.com/protesilaos/spacious-padding/issues/41.

• Official page: https://protesilaos.com/emacs/emacs-lisp-elements
• Git repository: https://github.com/protesilaos/emacs-lisp-elements

Emacs Lisp Elements version 2.0.0

This is a major rewrite of the book. It has almost doubled in word count. I explain more concepts and do it from the ground up. Every single one of the original chapters is redone. They now contain insights into functionality they would previously hint at, such as how apply works in practice, what a non-local exit is, and how recursive editing is done.

I have also added several new chapters. As before, chapters have cross references, so you will benefit from revisiting relevant topics.

If you read the Info version of the book, note that all functions, variables, and concepts have their own indices. Use those as another means of navigating the book’s contents. To read the Info version, clone the Git repository, use M-x dired to open its directory, move the cursor over the file elispelem.info and do M-x dired-info.

What follows is a brief description of the new chapters.

• Basics of how Lisp works: A step-by-step guide to how Lisp code is written and how Emacs can tell apart a function call from a variable even when those have the same symbol.

• Introspecting Emacs: Explores some of the ways we can learn about the present state of Emacs. The idea is to develop the habit of asking Emacs about itself before we do an online search. This way we can also expose ourselves to Elisp code, which helps us become better programmers.

• Add metadata to symbols: An explanation of how we can associate symbols with data that can then be used for further computations.

• What are major and minor modes: Presents the basics of modes in Emacs. It explains what major and minor modes have in common and how they differ, while also discussing relevant concepts of precedence.

• Hooks and the advice mechanism: Explains what are hooks and how they work. It also covers the powerful advice mechanism, as some uses of it as similar to what hooks are supposed to do.

• Autoloading symbols: Shows how Emacs manages to “lazy load” code when it needs to. This is especially helpful for package developers.

• Emacs as a computing environment: A more general view of Emacs that helps us appreciate the value of Emacs Lisp. The more time we put into learning this programming language, the better we will get at controlling large parts of our computing life through Emacs.

• Package name (GNU ELPA): pulsar
• Official manual: https://protesilaos.com/emacs/pulsar
• Change log: https://protesilaos.com/emacs/pulsar-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/pulsar
  • GitLab: https://gitlab.com/protesilaos/pulsar
• Backronym: Pulsar Unquestionably Luminates, Strictly Absent the Radiation.

Below are the release notes.

Version 1.3.0 on 2025-11-30

This version introduces a new feature and makes small refinements to an already reliable base.

Permanent static highlight for a line or region

In the most common use-case, Pulsar produces a highlight that fades in and out of view after a certain amount of time. The idea with such a “pulse effect” is to quickly get a sense of where the cursor is when some change occurs (e.g. switching to another window).

The permanent static highlights differ from pulse effects in two ways: (i) they do not have a fade-in and fade-out phase and (ii) are not removed automatically. These highlights stick around either until the user removes them or their underlying text is deleted. They are meant to be used as intentional highlights, such as to draw attention to a certain statement while doing a presentation.

The command pulsar-highlight-permanently adds a permanent static highlight to the current line. When the region is active, the highlight is applied from the beginning to the end of the region.

The command pulsar-highlight-permanently-remove removes permanent static highlights from the active region or current line. This command operates on the entire buffer when it is called with a universal prefix argument (C-u by default).

The command pulsar-highlight-permanently-dwim adds a permanent static highlight if there is none or removes it if there is one. It operates on the currently active region or line at point.

Permanent static highlights are rendered with the face specified in the user option pulsar-highlight-face.

New name for temporary static highlights

The commands pulsar-highlight-dwim and pulsar-highlight-line are obsolete aliases for pulsar-highlight-temporarily.

Temporary static highlights do not have a fade-in and fade-out phase. They are automatically removed as soon as an action occurs. They are an alternative to the aforementioned permanent static highlights.

The command pulsar-highlight-temporarily will operate on the active region or the current line.

Miscellaneous

• Thanks to Koloszár Gergely for reporting an intermediate bug where the pulse effect actually did not pulse under certain conditions. This was done in issue 31: https://github.com/protesilaos/pulsar/issues/31.

• Parts of the code are rewritten in the interest of clarity.

• The entire manual is redone to better organise the documentation.

These substitutions are meant to be as quick as possible and, as such, differ from the standard query-replace (which I still use when necessary). The provided commands prompt for substitute text and perform the substitution outright, without moving the point. The target is the symbol/word at point or the text corresponding to the currently marked region. All matches in the given scope are highlighted by default.

• Package name (GNU ELPA): substitute
• Official manual: https://protesilaos.com/emacs/substitute
• Git repositories:
  • GitHub: https://github.com/protesilaos/substitute
  • GitLab: https://gitlab.com/protesilaos/substitute
• Video demo: https://protesilaos.com/codelog/2023-01-16-emacs-substitute-package-demo/
• Backronym: Substitutions Uniformly Beget Standardisation for Text Invariably Transfigured Unto This Entry.

Below are the release notes.

Version 0.4.0 on 2025-11-29

This version iterates on an already stable package. It introduces a few new commands while making minor internal refinements.

The new commands work exactly like those already on offer, except for their scope of application. Remember that Substitute targets either the symbol/word at point or any occurrences of the currently marked characters/text within the given scope and replaces them with the user’s input. The scope is something like “current function definition”, “current paragraph”, “from here to the end of the buffer”, et cetera. The substitution does not move the cursor.

The new commands:

• substitute-target-in-outline: Substitute the target across the current outline level. The outline is determined by the buffer-local value of the variable outline-regexp. For example, in Org mode the current outline level includes the heading and any text below it but not any subheadings.

• substitute-target-in-page: Like the above for the boundaries of the current page. A page is determined by the buffer-local value of the variable page-delimiter.

• substitute-target-in-paragraph: As above for the current paragraph. Note that in programming modes a “paragraph” is not necessarily the same as with prose (where, in their simplest form, paragraphs are delimited by empty lines). Substitute highlights all matches by default, so users should notice the difference right away.

• substitute-target-in-defun-and-below: This works in the scope of the current definition (per narrow-to-defun) but only from point onwards. It is the counterpart to the commands we always had in substitute-target-in-defun.

The current development target of the Modus themes includes the function modus-themes-generate-palette. I have updated the manual with a detailed, step-by-step guide on how to use that function to derive a custom theme. I am doing it with Solarized, since it is well-known. Start here: https://protesilaos.com/emacs/modus-themes#h:3a7ede17-f0d4-4322-8e69-1804ed69012b

The reason I wrote this function is to make it easier for users to get started with their Modus ports. The common workflow is for someone to copy a colour scheme from their favourite terminal emulator and use it as a starting point for their Emacs theme. Modus will do the heavy lifting in the background.

modus-themes-generate-palette returns a fully fledged Modus palette: the literal hundreds of entries are all defined, even if we only give it a couple of colour values. The more colours we specify, the more defined the character of the resulting palette will be—and we have complete control, as the manual demonstrates.

A good starting point is to provide values for the main background (bg-main), main foreground (fg-main), and the basic hues of red, green, yellow, blue, magenta, and cyan.

Options for power users are available. Though the point is to lower the barrier to entry for those who want to start with something tolerable. Then they can trust that I cover everything they need to gradually evolve their theme to be as complete as core Modus.

In the manual I used Solarized as an example, with usable code snippets that you can copy+paste. Those yield a theme, if you try them. Below is a complete, albeit generic, Modus+Solarized theme. It is a decent starting point.

;; Modus+Solarized dark
(defvar modus-solarized-dark-palette
  (modus-themes-generate-palette
   '((bg-main "#073642")
     (fg-main "#EEE8D5")
     (red "#DC322F")
     (green "#859900")
     (yellow "#B58900")
     (blue "#268BD2")
     (magenta "#D33682")
     (cyan "#2AA198"))))

(modus-themes-theme
 'modus-solarized-dark
 'modus-solarized-themes
 "Sample of a basic Solarized dark port."
 'dark
 'modus-solarized-dark-palette
 nil
 nil)

Do not rush to play around with this snippet. The chapter in the manual I linked to above has much more about this topic. Take some time to read through it. You can extend the port to also map out all the colors you want. Thus:

;; Modus+Solarized dark
(defvar modus-solarized-dark-palette
  (modus-themes-generate-palette
   ;; We provide the two base colors of Solarized, plus most of its
   ;; accents.  These form the BASE-COLORS we pass as an argument.
   ;; All other color values come from those.  The BASE-COLORS here
   ;; are enough to generate a new palatte that has no traces of, say,
   ;; the `modus-vivendi' color values.
   '((bg-main "#073642")
     (fg-main "#EEE8D5")
     (red "#DC322F")
     (green "#859900")
     (yellow "#B58900")
     (blue "#268BD2")
     (magenta "#D33682")
     (cyan "#2AA198"))
   ;; The COOL-OR-WARM-PREFERENCE is derived internally based on
   ;; `bg-main'.  We can pass it here if we feel strongly about it.
   nil
   ;; If we need to specify the CORE-PALETTE from where to inherit any
   ;; missing colors and/or semantic mappings, we can give it here.
   ;; Though nil is the appropriate starting point, as the code will
   ;; handle things internally.
   nil
   ;; And here are our MAPPINGS where we can specify what values apply
   ;; to which semantic color.  The `modus-themes-list-colors' shows
   ;; them all.
   ;;
   ;; Note that in our BASE-COLORS above we never wrote what, say,
   ;; `magenta-warmer' is: it is derived programmatically from the
   ;; `magenta' we have there.  Absent that, it would be taken from
   ;; the CORE-PALETTE.
   '((cursor magenta-warmer)
     (bg-hl-line bg-blue-nuanced)
     (bg-paren-match bg-magenta-subtle)
     (bg-region bg-blue-intense)
     (fg-region fg-dim)
     (bg-mode-line-active bg-blue-nuanced)
     (fg-mode-line-active blue-warmer)
     (border-mode-line-active blue-cooler))))

(modus-themes-theme
 'modus-solarized-dark
 'modus-solarized-themes
 "Sample of a basic Solarized dark port."
 'dark
 'modus-solarized-dark-palette
 nil
 nil)

Using this infrastructure, I am confident that we can implement any colour scheme as a Modus theme—and, again, we can configure every part of it.

The manual is extensive, though remember that I remain at your disposal in case something is unclear: open an issue in the Modus themes repository or contact me and I will help you.

Sources

• Package name (GNU ELPA): modus-themes (also built into Emacs)
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

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.

Update to doric-themes 0.5.0

Enjoy the two new members of the collection

These are doric-siren and doric-mermaid. The former is a light theme while the latter is dark. Both themes offer a marine vibe combined with warm hues. Check the updated screenshots of all the Doric themes: https://protesilaos.com/emacs/doric-themes-pictures.

Support for transient.el semantic faces

Those are used when the user option transient-semantic-coloring is set to a non-nil value (the default). They are designed to indicate different types of key, such as those that keep the transient in place as opposed to exiting it.

The old style of making all key bindings look the same is still available if transient-semantic-coloring is set to nil.

Semantic Emacs Lisp faces

This is a new feature coming in Emacs 31. Users can opt in to it by setting the user option elisp-fontify-semantically to a non-nil value. When active, Emacs Lisp buffers will apply highlights to more elements of the syntax. Those will still conform with the minimalist style of the Doric themes, but users at least get the benefits of elisp-add-help-echo.

Font-lock faces for function calls and use of variables

Those are typically applied by major modes that are power by tree-sitter. Again, the styles are minimalist.

More faces or face groups are covered

These include:

• ibuffer’s Emacs 31 faces (patched by me in emacs.git)
• flymake’s Emacs 31 faces (again, my patch in core)
• diff-hl package
• git-gutter package
• org-habit
• minibuffer-nonselected for Emacs 31
• eglot-highlight-symbol-face
• ert-test-result-unexpected and ert-test-result-expected, courtesy of Rudolf Adamkovič in pull request 19: https://github.com/protesilaos/doric-themes/pull/19.

Refinements to already supported faces

• The calendar-today and org-date-selected are similar but different enough to stand apart. I initially made them look identical because I thought they would never appear in the same context. Thanks to Rudolf Adamkovič for telling me they could actually be collocated, hence their disambiguation. This was done in issue 20: https://github.com/protesilaos/doric-themes/issues/20.

• The transient-argument and transient-value have a background to make them easier to spot. This is because they convey information about the state of the transient interface, which typically is important.

• Transient’s mismatching keys are dimmed out instead of being underlined, because this looks better in context.

• Similarly, org-agenda-clocking has a more pronounced background.

• Idem for eldoc-highlight-function-argument and its counterparts in lsp-mode and geiser.

• The Org check boxes are rendered with a bold weight, while quote blocks are in italics. Thanks to Rudolf Adamkovič for the patch in pull request 18: https://github.com/protesilaos/doric-themes/pull/18.

• All Notmuch cryptography-related faces have more refined styles to both stand out better while avoiding exaggerations.

• The Custom user interface buttons inherit from variable-pitch.

• The current line number in display-line-numbers-mode uses just a bold weight to avoid exaggerations.

• https://github.com/protesilaos/denote-org/issues/16.
• https://github.com/protesilaos/denote/issues/649.
• https://github.com/protesilaos/denote-merge/issues/1.

The denote-merge package is a more refined implementation of those ideas, plus more. As of now, the package provides support for two broad kinds of “merging”:

• Merge one file into another.
• Merge a region into a file.

For merging a region, in particular, there are options and concomitant convenience commands to format the region in a certain way, such as an Org source block, a Markdown blockquote, a plain indented region, and the like.

The official manual describes the technicalities. In short, I have taken care to make the relevant commands do the right thing, including to update backlinks, annotate the contents, and establish links, where relevant.

Note that the GNU ELPA package is not available yet. I have prepared the relevant patch and am expecting everything to be done in the near future.

Please stay tuned.

Sources

• Package name (GNU ELPA): denote-merge (Coming soon!!!)
• Official manual: https://protesilaos.com/emacs/denote-merge
• Git repository: https://github.com/protesilaos/denote-merge
• Backronym: Denote… Merging Eventually Reformats the Given Entries.

[ Or just check all the pictures: https://protesilaos.com/emacs/doric-themes-pictures. ]

doric-siren

doric-mermaid

Coming in doric-themes version 0.5.0

The character of the themes is established and, in principle, I will not change them further. Though I am giving it a few more days of further testing to confirm I did not miss something. Expect these and other improvements to be available in the next stable version of the doric-themes, which I expect to publish before the end of November.

About the Doric themes

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. Legibility is still high.

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.

commit c94938ff794d043447ed4ffe9b55f1031039f667
Author: Protesilaos Stavrou <info@protesilaos.com>
Date:   Mon Nov 10 13:02:49 2025 +0200

  Greatly expand the manual with complete examples of creating Modus derivatives

  This covers the basic and more advanced use cases. It also is for both
  private use and making new packages.

 doc/modus-themes.info | 588 +++++++++++++++++++++++++++++++++++++-------------
 doc/modus-themes.org  | 278 +++++++++++++++++++++++-
 2 files changed, 711 insertions(+), 155 deletions(-)

The relevant sections and their structure:

• Build on top of the Modus themes
  • Complete example of a Modus derivative theme
    • Complete example of a package that is derived from Modus
    • Complete example of a private theme derived from Modus
    • Complete example of a custom theme with its own palette

If something is unclear, you are welcome to contact me.

In practice, the Standard themes take the default style of the font-lock and Org faces, complement it with a wider and harmonious colour palette, address many inconsistencies, and apply established semantic patterns across all interfaces by supporting a large number of packages.

• Package name (GNU ELPA): standard-themes
• Official manual: https://protesilaos.com/emacs/standard-themes
• Change log: https://protesilaos.com/emacs/standard-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/standard-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/standard-themes
  • GitLab: https://gitlab.com/protesilaos/standard-themes
• Backronym: Standard Themes Are Not Derivatives but the Affectionately Reimagined Default … themes.

Below are the release notes.

Version 3.0.0 on 2025-11-09

This major version makes Standard build on top of my Modus themes. The latter provides extensive face/package coverage and a wide range of customisation options. As a result, the Standard themes retain their design while giving more control to the user.

These release notes are essentially the same as what I wrote earlier today for my ef-themes package, which is now also built on top of my Modus themes: https://protesilaos.com/codelog/2025-11-09-emacs-ef-themes-2-0-0/.

In short:

• User options that were provided by the Standard themes are now mere aliases for their Modus counterparts.
• Commands that were defined by the Standard themes are now reduced to convenience wrappers that build on top of Modus.
• The new minor mode standard-themes-take-over-modus-themes-mode can be enabled to make all Modus commands that load a theme only consider the Standard themes. This is effectively the opposite of enabling the modus-themes-include-derivatives-mode or using one of the Standard commands to load just a Standard theme (like standard-themes-rotate).
• The manual of the Modus themes covers everything from the basics to advanced topics on how to use and customise the themes. Evaluate (info "(modus-themes) Top") or visit https://protesilaos.com/emacs/modus-themes.

You are welcome to contact me if something is unclear.

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

Below are the release notes.

Version 2.0.0 on 2025-11-09

The Ef themes are now derived from my Modus themes. This means that they inherit the wide face coverage and extensive customisability of Modus, while retaining their stylistic flair.

The Ef themes no longer provide any user options of their own. Each of the options we had before is now an alias for the Modus equivalent. As part of this transition, the Ef themes actually gain new customisation options, which are documented herein.

Furthermore, the Ef themes do not define any commands to load a theme. What we had before is once again an alias for the equivalent Modus command.

The manual of the Ef themes describes these compatibility arrangements. Further documentation and code samples are available in the manual of the Modus themes:

• Info page: Evaluate (info "(modus-themes) Top").
• Weg page: Visit https://protesilaos.com/emacs/modus-themes.

Old user options and hooks are mere aliases for Modus options

Please read their respective documentation strings.

If you use Ef and possibly other Modus derivatives, you may prefer to switch all your user options to the Modus ones. This way you can keep a unified configuration for all your themes.

Fewer bold and italic faces by default, more as an opt-in clause

In the past, the Ef themes did not provide an option to disable the extensive use of a bold font weight and italic font slant. Whereas now those are controlled by the user options modus-themes-bold-constructs and modus-themes-italic-constructs. By default, when they are nil, bold and italics are used only when necessary. Set these user options to t to have bold and italics in more places.

Loading only Ef themes with the convenience wrappers we provide

All the old commands Ef provided for loading one of its themes will still work as before, meaning that they will only ever show and load a theme that belongs to the Ef collection.

Internally, these commands are now using the Modus infrastructure and are then limiting the set of themes to the Ef collection. They are thus convenience wrappers around the equivalent Modus commands.

• ef-themes-toggle
• ef-themes-rotate
• ef-themes-select
• ef-themes-load-random
• ef-themes-load-random-dark
• ef-themes-load-random-light

Additionally, the commands ef-themes-list-colors and ef-themes-list-colors-current use the relevant Modus functionality under the hood while working only with the Ef themes.

Combining core Modus themes with all their derivatives

The minor mode modus-themes-include-derivatives-mode makes all the theme-loading commands that Modus defines consider all core and derivative themes. This means that something like modus-themes-select will offer modus-operandi and ef-summer as two of the many possible candidates.

In this scenario, the Modus and Ef collections become part of a larger family of themes as opposed to only considering one or the other (Loading only Ef themes with the convenience wrappers we provide). Enable modus-themes-include-derivatives-mode and then access them all with the following commands:

• modus-themes-toggle
• modus-themes-rotate
• modus-themes-select
• modus-themes-load-random
• modus-themes-load-random-dark
• modus-themes-load-random-light
• modus-themes-list-colors
• modus-themes-list-colors-current

Consult the manual of the Modus themes for further details and/or read the documentation string of each command.

Taking over the Modus commands altogether

The minor mode ef-themes-take-over-modus-themes-mode makes all Modus commands that load a theme consider only Ef themes. This is the opposite of allowing different theme collections to be blended together (Combining core Modus themes with all their derivatives). It effectively is the same as using one of the convenience wrapper commands we already provide (Loading only Ef themes with the convenience wrappers we provide).

This minor mode exists to accommodate the needs of users who install both the Modus and Ef theme packages (and possibly other Modus derivatives). They can maintain a single/shared configuration and then decide when to enable ef-themes-take-over-modus-themes-mode to switch to using just the Ef themes.

For example, in the morning the user only wants to consider the Modus themes, but during the evening they only likee the Ef themes. In this scenario, a key binding to, say, modus-themes-rotate does not need to be updated: it internally reads only Ef themes when ef-themes-take-over-modus-themes-mode is enable. When this minor mode is disabled, that same key binding will revert to doing what it did before (load only a core Modus theme or Modus plus derivatives if modus-themes-include-derivatives-mode is enabled).

More semantic palette mappings

Modus has always had a more comprehensive palette than Ef. Now they are on par. Concretely, this means that users can customise more of the theme’s style to their liking. Use the commands that list/preview a palette to learn about all the available options.

The manual of the Modus themes covers the palette and user-defined overrides at great length. It also includes code samples that you can use as a starting point. And if something is unclear, you are welcome to contact me.

Many more faces are covered

The wide face/package coverage of Modus is now inherited by the Ef themes. If some interface you are using does not look right, then the underlying faces are probably not supported yet. Contact me and I will take care of it right away.

• Package name (GNU ELPA): modus-themes (also built into Emacs 28+)
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

5.1.0 on 2025-11-07

This version fixes a critical bug in the modus-themes-with-colors macro. In short, it was not working as before or was not working at all. Now it should do the right thing.

Thanks to Alexandr Semenov for reporting a relevant bug in issue 170 and for helping me test the results: https://github.com/protesilaos/modus-themes/issues/170.

Thanks to Stéphane Marks for testing some configurations with the latest stable Emacs version as well as with builds from emacs.git. This was done via a private channel and I am sharing this information with permission.

Also thanks to Stefan Monnier for monitoring my commits as I was trying to refactor the modus-themes-with-colors macro. Some comments were posted on the emacs-devel mailing list, as well as a patch that I ended up applying and then reverting (check the commit log for the technicalities): https://lists.gnu.org/archive/html/emacs-devel/2025-11/msg00114.html.

Apologies to everyone for the inconvenience! This was a tricky bug. The good thing is that it compelled me to improve several parts of the code.

This version also includes a clarification in the manual about building a theme on top of Modus:

• Web page: Visit https://protesilaos.com/emacs/modus-themes#h:86eb375b-9be4-43ce-879a-0686a524a63b.
• Info manual: Evaluate (info "(modus-themes) Build on top of the Modus themes").

In short, it mentions that a theme exists in an appropriately named file that is part of the custom-theme-load-path. Thanks to Ashton Wiersdorf for asking a related question in issue 171: https://github.com/protesilaos/modus-themes/issues/171.

• Package name (GNU ELPA): modus-themes (also built into Emacs 28+)
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

5.0.0 on 2025-11-01

This is a major release. There are some small breaking changes. The big new feature is that Modus can be used as the basis for other theme projects. Two of my other theme packages, the ef-themes and the standard-themes are already done in this way: their next major versions will formalise what I have been developing for a while now (though the doric-themes will remain their own thing for the time being).

Build on top of Modus

This is of immediate interest to package developers or advanced users. It changes nothing for existing users of the Modus themes. Please refer to the manual on the matter and feel welcome to contact me if you have any questions—I am happy to help.

Evaluate:

(info "(modus-themes) Build on top of the Modus themes")

Or visit: https://protesilaos.com/emacs/modus-themes#h:86eb375b-9be4-43ce-879a-0686a524a63b.

Why build on top of Modus? To benefit from (i) the wide face coverage and extensive detail-oriented testing, (ii) the use of palette mappings, (iii) the palette preview done with modus-themes-list-colors or related, (iv) the inclusion of the derivative theme in the workings of all Modus commands that load a theme, like modus-themes-rotate and modus-themes-select (see the new minor mode modus-themes-include-derivatives-mode).

Derivative themes can be as simple as a few extra colours on top of, say, modus-operandi. They can also be more involved, with new palette mappings and custom faces that use them. Such themes can define commands which load only their own themes (see modus-themes-define-derivative-command) and they can even take over the Modus themes completely, in terms of becoming the only ones that are exposed to the commands that load a theme, like modus-themes-rotate and modus-themes-select.

Thanks to Suleyman Boyar for fixing an intermediate omission with an earlier version of the code that derives a theme. I did eventually change the whole approach to use a function instead of a macro, but Suleyman’s contribution was still useful at the time. This was done in pull request 156: https://github.com/protesilaos/modus-themes/pull/156. The change is small, meaning that Suleyman does not need to assign copyright to the Free Software Foundation.

Colours can be copied from the palette preview buffer

The commands modus-themes-list-colors and modus-themes-list-colors-current display the given theme’s palette in a tabulated listing. Each line visualises the colour it references. From that buffer it is now possible to call the following commands (bound to the modus-themes-preview-mode-map):

The modus-themes-preview-mode-copy-color and its modus-themes-preview-mode-copy-entry counterpart work on the line at point or those that are marked. The first copies the resolved colour value, as a string (“resolved” here means that it will find what a palette mapping actually stands for). The second gets the complete palette entry, as it appears in the underlying definition. This is a starting point for writing palette overrides.

Thanks to shimeike for reporting a problem with a regression I introduced by mistake in one of the development versions of the function that handles the creation of the tabulated list. This was done in issue 163: https://github.com/protesilaos/modus-themes/issues/163.

New semantic palette mappings for programming contexts

The fnname-call and variable-use are now available. They are applied to faces that are used by major modes which build on top of tree-sitter program as well as the Emacs Lisp semantic highlighting feature of Emacs 31.

By default, these colours are more subtle than their fnname and variable counterparts. The reason is that I want to avoid exaggerations with the wanton application of colour (“avoiding exaggerations” is one of the design principles of the Modus themes).

Because of the commitment to the highest legibility standard for colour contrast, we are using colours that stand out in their context, yet are still harmonious with each other. This is due to (i) careful consideration of colour harmonies, (ii) enforced uniformity of styles where necessary to avoid emphasising the emphasis or stating the obvious, and (ii) the fact that not too many intense colours appear in close proximity to each other in most Emacs major modes. If a major mode or other feature adds colours virtually everywhere, then the Modus themes are no longer true to their character and become borderline unusable.

The more subtle colours for fnname-call and variable-use do not prevent exaggerations, though they do make them less egregious.

[ Note that themes do not control which face is applied where. That is the job of a major mode or specialised minor modes. When in doubt, work with the rule that fewer colours are better than many. ]

Support for Emacs Lisp semantic highlighting

This is built into Emacs version 31. What it does is make different parts of the Elisp syntax stand out visually. It also augments them with a mouse tooltip (technically a help-echo) that provides valuable insights about what the thing is.

Thanks to Eshel Yaron, the author of this feature, for (i) asking me to review the relevant faces, (ii) helping me understand what “semantic highlighting” is intended for, and (iii) explaining to me how some faces are meant to be used. This was done in the context of Emacs bug 79677 and in an aside about a change to my minimalist doric-themes package:

• https://lists.gnu.org/archive/html/bug-gnu-emacs/2025-10/msg01156.html.
• https://lists.gnu.org/archive/html/emacs-devel/2025-10/msg00728.html.

I wrote to Eshel that I do not want many colours clustered together. This design is more suitable to themes with low intensity. All my themes exacerbate the effect of dense colouration due to their primary design goal: legibility.

Currently the added colouration of semantic highlighting is noticeable far more than I like. This is a compromise on my end. Future versions of the themes might set more semantic faces to nil (or anyhow make them subtle), subject to further review and user feedback.

This is not a position against semantic highlighting, but a comment on inconsiderate themes.

More elements are optionally bold or italic

I have revised all supported faces to make them more conservative about when they apply typographic qualities that deviate from the default font. Many faces that were unconditionally rendered with a bold weight or an italic slant are now subject to the user options modus-themes-bold-constructs and modus-themes-italic-constructs.

This means that they are like the default font family by default and will become bold/italic if the relevant user option is set to a non-nil value.

Faces that are semantically bold or italic and/or which genuinely benefit from such typographic attributes out-of-the-box are exempt from this.

Headings are also exempt because they are anyway subject to the user option modus-themes-headings which covers the height and weight of each heading level’s text.

Thanks to chainedghost for reporting a regression in one of the commits I made. This was done in issue 167: https://github.com/protesilaos/modus-themes/issues/167

Support for lsp-mode and lsp-ui packages

Thanks to Jimmy Yuen Ho Wong for the initial contribution in pull request 142: https://github.com/protesilaos/modus-themes/pull/142. I made some changes on top to use semantic palette mappings, where applicable, and other such tweaks.

The minibuffer-nonselected face is supported

This is coming in Emacs version 31: it highlights the active minibuffer when the cursor is in another window. The face is designed to be as noticeable as possible because this kind of scenario usually leads to mistakes or confusion.

Refinements to supported packages or face groups

• The markdown-code-face uses the same semantic palette mapping as org-block. This was always the intent. Thanks to Frédéric Giquel for the fix in pull request 160: https://github.com/protesilaos/modus-themes/pull/160. The change is small and thus does not require copyright assignment to the Free Software Foundation.

• Fixed a word in the symbol of the flymake-warning-echo-at-eol. Thanks to Eric Ottosson for the patch in pull request 145: https://github.com/protesilaos/modus-themes/pull/145. No copyright assignment is required.

• The two new Emacs 31 faces for packages that are marked for installation or deletion in the M-x list-packages buffer are now included. Thanks to Gautier Ponsinet for sending me the patch. Gautier has assigned copyright to the Free Software Foundation.

• The hs-ellipsis in Emacs 31 from the built-in hideshow package is also covered. It is made to conform with established patterns across conceptually equivalent faces (e.g. Org folded headings) rather than do its own thing.

• The widget-field uses an underline to be easier to spot. On supported Emacs displays (generally graphical Emacs) the underline is at the descent line, meaning that it does not cross through characters with descenders like g.

• The git-commit and log-edit faces for writing commit messages in Magit and VC are tweaked to avoid exaggerations.

• The Magit section headings have a slightly modified foreground value.

• The org-list-dt face for list definition terms has a slightly modified foreground value to (i) be easier to spot while (ii) being less intense overall.

• The calendar-today in the M-x calendar interface now has a box around it on supported displays (graphical Emacs) to better stand out from its context. On unsupported displays, the face still gets an appropriate background value.

• The org-date-selected and calendar-today should look the same, contrary to how they did before. This is done in the interest of theme-wide consistency (i.e. the kind of detail you appreciate once it is no longer there).

• The mode lines use an underline on displays that cannot render a box. This way, the faces remain distinct from their context.

• All interface buttons, like those that appear in the Custom buffers, will be rendered with an underline on displays that cannot handle boxes.

• The notmuch-message-summary-face, which is used in threaded message views, now has an overline on supported displays (graphical Emacs). Individual messages in the thread should thus be more discernible.

• The tab-bar-tab-highlight is directly covered to make sure all mouse hover effects are consistent across similar interfaces.

• Some faces that had specific colour values (e.g. cyan-cooler) are revised to use semantic palette mappings instead. This ensures thematic consistency. The most obvious beneficiaries are users of the deuteranopia- and tritanopia- optimised themes (deuteranopia-friendly themes cannot work with red and green while tritanopia-friendly themes must not rely on yellow and blue).

The modus-themes-custom-auto-reload is obsolete

Plus all our user options no longer specify a :set function. This means that the theme will never be reloaded automatically when using the Custom interface or setopt to configure one of the theme’s user options. Reloading the theme is what applies the new styles. The idea of this feature is good, but the implementation was problematic. Maybe I will reinstate it in the future, though I cannot let it block this major release.

Several modus-themes-* faces are obsolete

In previous versions I was defining faces that were used to apply uniform styles across many packages. This was the old way of doing things before version 4.0.0 of the themes that introduced palettes with semantic mappings and, optionally, user-defined overrides to them.

I have deprecated all of the following and made all the necessary changes (i.e. several thousands of them), to make palette mappings the norm everywhere. In general, I encourage you not to rely on any faces defined by Modus: they are really intended for internal use.

• modus-themes-fg-blue
• modus-themes-fg-blue-cooler
• modus-themes-fg-blue-faint
• modus-themes-fg-blue-intense
• modus-themes-fg-blue-warmer
• modus-themes-fg-cyan
• modus-themes-fg-cyan-cooler
• modus-themes-fg-cyan-faint
• modus-themes-fg-cyan-intense
• modus-themes-fg-cyan-warmer
• modus-themes-fg-green
• modus-themes-fg-green-cooler
• modus-themes-fg-green-faint
• modus-themes-fg-green-intense
• modus-themes-fg-green-warmer
• modus-themes-fg-magenta
• modus-themes-fg-magenta-cooler
• modus-themes-fg-magenta-faint
• modus-themes-fg-magenta-intense
• modus-themes-fg-magenta-warmer
• modus-themes-fg-red
• modus-themes-fg-red-cooler
• modus-themes-fg-red-faint
• modus-themes-fg-red-intense
• modus-themes-fg-red-warmer
• modus-themes-fg-yellow
• modus-themes-fg-yellow-cooler
• modus-themes-fg-yellow-faint
• modus-themes-fg-yellow-intense
• modus-themes-fg-yellow-warmer
• modus-themes-intense-blue
• modus-themes-intense-cyan
• modus-themes-intense-green
• modus-themes-intense-magenta
• modus-themes-intense-red
• modus-themes-intense-yellow
• modus-themes-key-binding
• modus-themes-lang-error
• modus-themes-lang-note
• modus-themes-lang-warning
• modus-themes-mark-alt
• modus-themes-mark-del
• modus-themes-mark-sel
• modus-themes-nuanced-blue
• modus-themes-nuanced-cyan
• modus-themes-nuanced-green
• modus-themes-nuanced-magenta
• modus-themes-nuanced-red
• modus-themes-nuanced-yellow
• modus-themes-prominent-error
• modus-themes-prominent-note
• modus-themes-prominent-warning
• modus-themes-prose-code
• modus-themes-prose-macro
• modus-themes-prose-verbatim
• modus-themes-search-current
• modus-themes-search-lazy
• modus-themes-search-replace
• modus-themes-search-rx-group-0
• modus-themes-search-rx-group-1
• modus-themes-search-rx-group-2
• modus-themes-search-rx-group-3
• modus-themes-search-static
• modus-themes-subtle-blue
• modus-themes-subtle-cyan
• modus-themes-subtle-green
• modus-themes-subtle-magenta
• modus-themes-subtle-red
• modus-themes-subtle-yellow

Thanks to Kevin Fleming and Jimmy Yuen Ho Wong for fixing two cases of unbalanced/faulty parentheses caused by the aforementioned. These were done as pull requests 166 and 168, respectively:

• https://github.com/protesilaos/modus-themes/pull/166.
• https://github.com/protesilaos/modus-themes/pull/168.

Both changes are small: no copyright assignment to the Free Software Foundation is needed (and I think both authors are covered, anyway).

All :inherit face attributes are reviewed and kept to a minimum

The themes now use the :inherit attribute much more cautiously than before. This is because of the reliance on semantic palette mappings: those give us more control and usually are explicit about the desired result.

Face inheritance can become circular in some cases. Newer Emacs versions throw an error accordingly. This was discussed in Emacs bug 79672, with participation from Eli Zaretskii, JD Smith, Manuel Giraud, Stephane Marks, and Steven Allen: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=79672.

Thanks to everybody involved!

Denote is based on the idea that files should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the contents are about, without reference to any other metadata. Denote basically streamlines the creation of such files or file names while providing facilities to link between them (where those files are editable).

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a constistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

Below are the release notes.

Version 4.1.0 on 2025-10-17

The overarching theme of version 4.1.0 is that of continuing to deliver on the highly hackable/flexible/powerful potential of Denote. All the core functionality is the same as before and you still only need a tiny configuration to use Denote productively. We are adding more refinements and subtle improvements under the hood, while making it even easier for advanced users/developers to piece together a workflow that matches their particular needs.

Since version 4.0.0, we have moved the “Denote extras” files into their own packages. I cover their changes further down after I elaborate on all the changes to the core Denote package:

• denote-journal version 0.2.0
• denote-org version 0.2.0
• denote-sequence version 0.2.0

Note that I write all the release notes by hand. The reason is that I consider this process an essential part of my role as a maintainer. Taking the time to review and document everything ensures that (i) I am well informed about the state of the package, (ii) I did not forget anything about this development cycle, and (iii) I take another look at the changes we made to ensure everything is in order.

Overview of the new features for core Denote

• The user option denote-directory can be assigned to a list of directories. The original string value is also acceptable and remains the default.

• Advanced users can define a completely custom scheme for identifiers. This can be as simple as automatically assigned ordinal numbers to increasingly complex patterns that may also involve user input.

• The command denote-find-backlink-with-location is like denote-find-backlink except it also moves to the exact location of the link in the corresponding file.

• All Denote buffer names share a common prefix, which is subject to the user option denote-buffer-name-prefix. This makes it easier to spot them in the buffer list.

• The command denote-dired (alias denote-sort-dired) can sort files by random and last-modified in addition to the methods that involve Denote file name components.

• The user option denote-query-sorting controls how files in all query buffers are sorted by default. This covers backlinks, query links for file contents, and any buffer produced by the denote-grep command. It benefits from the internal “Denote sort” mechanism, which is also used by denote-dired and the Org dynamic blocks of the denote-org package.

Remember that the release notes are true only at the time of publication. The single source of truth always is the official manual.

Set denote-directory to a list of directories

The user option denote-directory can optionally be bound to a list of file system paths, each of which represents a directory root, such as '("/home/prot/Documents/work/" "=/home/prot/Git/hut/") (Denote has always supported subdirectories, even for a singular denote-directory).

When creating new files, such as with the denote command, the first directory on the list will be selected. This can be changed by modifying the denote-prompts user option so that it asks for a directory or subdirectory thereof. Or by writing small wrapper commands that put files in a predefined directory, like this:

(defun my-denote-for-work ()
  "Like `denote' but always use the ~/Documents/work/ directory."
  (interactive)
  (let ((denote-use-directory "~/Documents/work/"))
    (call-interactively 'denote)))

Why have many directories as part of the denote-directory? Some users want to maintain separate directories with Denote files, while retaining the option of establishing links between (unlike the concept of “silos” we support, where the directories are self-contained). Those two directories can be their own Git repositories, for example, and have different syncing policies for access across multiple devices.

Thanks to Jean-Philippe Gagné Guay for providing the core functionality in pull request 609: https://github.com/protesilaos/denote/pull/609.

Jean-Philippe is a long-time contributor who has assigned copyright to the Free Software Foundation. I made several changes on top, such as to allow denote-dired (alias denote-sort-dired) to work with many directories, by finding their common root (which would ultimately be /).

Define completely custom Denote identifiers

The default Denote identifier should work for most people in most cases. I have considered the Denote file-naming scheme carefully and know it is reliable. Advanced users who have a clear use-case of something out-of-the-ordinary can now get “Denoted” file names with arbitrary identifiers. Since this is an advanced feature, I will not elaborate here on the technicalities. Though I have taken the time to write at length in the manual about it, with concrete examples ranging from simple to more complex scenaria. Start with this introduction: https://protesilaos.com/emacs/denote#h:3048f558-7d84-45d6-9ef2-53055483e801.

This feature has been discussed and requested for a long time, across several related issues:

• https://github.com/protesilaos/denote/issues/278.
• https://github.com/protesilaos/denote/issues/474.
• https://github.com/protesilaos/denote/issues/581.

Thanks, in no particular order, to mentalisttraceur, juh2, Christian Tietze, and Jean-Philippe Gagné Guay for sharing their thoughts. Also thanks to Jean-Philippe Gagné Guay for contributing the patches that made this possible, the last of which is in pull request 586: https://github.com/protesilaos/denote/issues/586.

Find a backlink at its exact location in the file

Denote has two ways of working with backlinks: (i) to display them in a dedicated buffer and (ii) to use a minibuffer prompt that supports completion in order to pick one file out of the list. The new command denote-find-backlink-with-location is of the latter kind. Like its more generic denote-find-backlink counterpart, it uses the minibuffer to pick a file that links to the current one. Then, it also moves the cursor to where the link is.

I did this is in response to issue 471 as reported by johkneisl: https://github.com/protesilaos/denote/issues/471.

Denote buffer names use the denote-buffer-name-prefix

This is a new user option that takes an arbitrary string. Its value is "[D]" by default. It consolidates how we name all of our buffers. Out-of-the-box, this applies to special buffers, like those produced by the commands denote-backlinks and denote-dired. When the optional minor mode denote-rename-buffer-mode is enabled, all buffers whose file naming scheme is that of Denote will get the denote-buffer-name-prefix in addition to their own denote-rename-buffer-format.

This is related to pull request 597 by James Kalyan: https://github.com/protesilaos/denote/pull/597. James has assigned copyright to the Free Software Foundation.

The Denote sort mechanism can sort by random and last-modified

In core Denote, this is used internally by the denote-dired command (alias denote-sort-dired) and the query buffers (more in the next section). By default, denote-dired prompts for the sort method and whether to reverse the order. Though there are user options to tweak its behaviour (consult the manual). The Org dynamic blocks of the denote-org package also rely on this mechanism (denote-org version 0.2.0).

Control the default sort of files in query buffers

Query buffers are those of denote-backlinks, denote-grep, and denote-query-contents-link (in the latter case, the query buffer is produced when you click on the link). Users can now modify how they sort matching files via the option denote-query-sorting. The sorting methods are by any of the Denote file names components (per denote-sort-components), random order, last modified, or an arbitrary function.

Thanks to Lucas Quintana for the contribution in pull request 594: https://github.com/protesilaos/denote/pull/594. Lucas has assigned copyright to the Free Software Foundation.

Miscellaneous for core Denote

• The denote-dired command (alias denote-sort-dired) sets up its revert-buffer-function in a more robust way, such that it does not affect the window layout under certain conditions.

• Fixed a bug with the menu entry of Denote that broke context-menu-mode. It addresses issue 592, as reported by artelse: https://github.com/protesilaos/denote/issues/592. Thanks to Lucas Quintana for the patch. Lucas has assigned copyright to the Free Software Foundation.

• Thanks to ryota for refining the documentation of the variable denote-use-template and its potential interference with denote-org-capture-identifiers in custom user code. We discussed this in issue 545 and the patch was sent as pull request 598:
  • https://github.com/protesilaos/denote/issues/545.
  • https://github.com/protesilaos/denote/pull/598. The change is small, meaning that ryota does not need to assign copyright to the Free Software Foundation.

• An internal check to determine if a file has backlinks is now faster than before: it exits with a non-nil value as soon as it finds one match, instead of trying to collect all the backlinks. Thanks to Yann Dutrieux for addressing an omission of mine in the original implementation and then for discussing with me some further refinements. Yann’s contribution was sent as pull request 637: https://github.com/protesilaos/denote/pull/637.

• Thanks to Alan Schmitt and Ashish Panigrahi for fixing a couple of typos, in pull requests 623 and 626, respectively:
  • https://github.com/protesilaos/denote/pull/623.
  • https://github.com/protesilaos/denote/pull/626.

Git commits for core Denote

~/Git/Projects/denote $ git shortlog 4.0.0..4.1.0  --summary --numbered
   156	Protesilaos Stavrou
    29	Jean-Philippe Gagné Guay
     4	Lucas Quintana
     2	James Kalyan
     1	Alan Schmitt
     1	Ashish Panigrahi
     1	Hanwen Guo
     1	Ryota
     1	Yann Dutrieux

Changes to the extensions of Denote I maintain

This concerns all the former “Denote extras” that were shipped with core Denote as well as consult-denote.

consult-denote version 0.4.0

• The commands consult-denote-grep and consult-denote-find also work when denote-directory is set to a list value, as explained further above (Set denote-directory to a list of directories).

• There is a Consult-powered counterpart to the denote-sequence-file-prompt. It is for users of the denote-sequence package and comes into effect when the consult-denote-mode is enabled (that mode “Consults” all relevant minibuffer prompts Denote uses so they get the familiar preview functionality). The denote-sequence-file-prompt is used by commands such as denote-sequence, denote-sequence-find, and denote-sequence-link, among others (denote-sequence version 0.2.0).

• The command consult-denote-find sorts its files by default. We discussed this with Gianluca Della Vedova and Gianluca implemented the tweak in pull request 18: https://github.com/protesilaos/consult-denote/pull/18. The change is small, meaning that Gianluca does not need to assign copyright to the Free Software Foundation.

denote-journal version 0.2.0

• It is now possible to specify the desired interval used by the command denote-journal-new-or-existing-entry to determine what “new” and “existing” mean. Users may want to, for example, maintain one file per month, with daily entries as headings or as free-form text. The user option denote-journal-interval specifies the interval as a symbol among daily, weekly, monthly, and yearly. Thanks to Ning Xu for floating the idea of non-daily journaling in issue 18: https://github.com/protesilaos/denote-journal/issues/18.
  • Thanks to Alan Schmitt for catching a couple of errors in my original implementation and for suggesting fixes in pull requests 20 and 21. Also thanks to Abdelhak Bougouffa for addressing another problem in pull request 23. Further changes by me.
    • https://github.com/protesilaos/denote-journal/pull/20.
    • https://github.com/protesilaos/denote-journal/pull/21.
    • https://github.com/protesilaos/denote-journal/pull/23.

• The new user option denote-journal-signature specifies a signature that will be applied to all new journal entries. It is the counterpart of denote-journal-keyword. Possible values are nil, for no predefined signature, a string for a constant signature, and a function that returns a string which is then used as-is. Thanks to Halogen3576 for suggesting an option for a signature in issue 13: https://github.com/protesilaos/denote-journal/issues/13.

  In the case of a function value, users may wish to integrate the denote-journal package with the denote-sequence package (denote-sequence version 0.2.0). For example, each new journal entry should be defined as a new parent sequence. Thus:

  (setq denote-journal-signature
        (lambda ()
          (denote-sequence-get-new 'parent)))
  

• The user option denote-journal-keyword is extended to support a function value which should return a string or list of strings.

• The integration with M-x calendar (when the minor mode denote-journal-calendar-mode is enabled) is more robust when highlighting dates that have a Denote journal entry. Thanks to Alan Schmitt for the patch that improves the check for visible dates only. This was done in pull request 12: https://github.com/protesilaos/denote-journal/pull/12.

• The denote-journal-calendar face is extended to also work when Emacs is ran in a TTY. Thanks to Ettore Berardi for the original contribution and for discussing this with me. It was done in pull request 14: https://github.com/protesilaos/denote-journal/pull/14. The contribution is less than 15 lines of code, meaning that Ettore does not need to assign copyright to the Free Software Foundation.

• The function denote-journal-path-to-new-or-existing-entry is tweaked to not kill the buffer of the new file it might generate. Thanks to jbwfu for the change in pull request 17: https://github.com/protesilaos/denote-journal/pull/17. The change is small, meaning that the author does not need to assign copyright to the Free Software Foundation.

• Dates with a single digit in the title of a new journal entry no longer have a space where the second digit normally is. So something like October 1 instead of October 1. Thanks to Josh Kingsley for the patch. The change is small, meaning that Josh does not need to assign copyright to the Free Software Foundation. It was done in pull request 24: https://github.com/protesilaos/denote-journal/pull/24.

• Thanks to gk2803 for renaming a couple of old symbols to their current names in the commentary of the package. This was done in pull request 10: https://github.com/protesilaos/denote-journal/pull/10.

  ~/Git/Projects/denote-journal $ git shortlog 0.1.0..0.2.0  --summary --numbered
      35	Protesilaos Stavrou
       3	Alan Schmitt
       2	Ettore Berardi
       1	Abdelhak Bougouffa
       1	Josh Kingsley
       1	gk2803
       1	jbwfu
  

denote-org version 0.2.0

• A new Org dynamic block integrates with the denote-sequence package (denote-sequence version 0.2.0). The block is called denote-sequence and can be inserted at point with the command denote-org-dblock-insert-sequence. What this block does is list the descendants of a given sequence up to a maximum depth. The presentation is a typographic list of lists to visualise the hierarchy of the complete sequence, with each set of children nested under its parent. Thanks to Peter Prevos for the original implementation in pull request 9 and for subsequent tweaks in pull request 13. Other changes by me are done to ensure tighter integration with the denote-sequence package.
  • https://github.com/protesilaos/denote-org/pull/9.
  • https://github.com/protesilaos/denote-org/pull/13.

• All Org dynamic blocks that have a :sort-by-component parameter can now sort by random and last-modified. This is made possible by the aforementioned improvements to the core Denote sort mechanism (The Denote sort mechanism can sort by random and last-modified).

• The denote-missing-links Org dynamic block, which can be inserted at point with the command denote-org-dblock-insert-missing-links takes an optional :not-regexp parameter. This is a regular expression of files to omit from the results. Same for the denote-backlinks block, which can be inserted at point with the command denote-org-dblock-insert-backlinks.

• The denote-files-as-headings Org dynamic block, which can be inserted at point with the command denote-org-dblock-insert-files-as-headings now also accepts an optional :exclude-tags parameter. It is either nil or non-nil and determines whether the heading will have the file’s #+filetags as its own tags. Thanks to Matt Nolan for suggesting this idea in issue 14: https://github.com/protesilaos/denote-org/issues/14.

  ~/Git/Projects/denote-org $ git shortlog 0.1.0..0.2.0  --summary --numbered
      42	Protesilaos Stavrou
       8	Peter Prevos
  

denote-sequence version 0.2.0

• The new commands denote-sequence-find-next-sibling and denote-sequence-find-previous-sibling move to the next or previous sibling in the given sequence. When called interactively, they work relative to the current file. When called from Lisp, they expect a SEQUENCE argument and its corresponding RELATIVES.

• The denote-sequence-dired command is updated to (i) work with a list value for denote-directory (Set denote-directory to a list of directories), as noted further above and (ii) benefit from the refinements done to denote-dired with regard to its revert-buffer-function.

• The new command denote-sequence-rename-as-parent makes it easier to apply the Denote file-naming scheme to an existing file and make it a new parent sequence. Thanks to Alex Carney for requesting something along those lines in issue 4: https://github.com/protesilaos/denote-sequence/issues/4.

  [ Remember that Denote is highly adaptable/hackable, meaning that many of these convenience commands build on top of the core with small extensions to it. The body of denote-sequence-rename-as-parent is only 4 lines long, two of which are for an error check. This is typical of much of what we provide and is how users can always extend Denote to do something slightly different than what we support out-of-the-box. ]

• Made several other refinements under the hood, including the addition of more tests. In this regard, thanks to Rory Molinari, Peter Prevos, and Ashton Wiersdorf for fixing three bugs in pull requests 5, 8, and 11, respectively:

  • https://github.com/protesilaos/denote-sequence/pull/5.
  • https://github.com/protesilaos/denote-sequence/pull/8.
  • https://github.com/protesilaos/denote-sequence/pull/11.

  ~/Git/Projects/denote-sequence $ git shortlog 0.1.0..0.2.0  --summary --numbered
      61	Protesilaos Stavrou
       1	Ashton Wiersdorf
       1	Peter Prevos
       1	Rory Molinari
  

Changes to denote-markdown

Nothing of substance.

Changes to denote-silo

Nothing of substance.

• Package name (GNU ELPA): tmr
• Official manual: https://protesilaos.com/emacs/tmr
• Change log: https://protesilaos.com/emacs/tmr-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/tmr
  • GitLab: https://gitlab.com/protesilaos/tmr
• Backronym: TMR May Ring; Timer Must Run.

Below are the release notes.

Version 1.2.0 on 2025-10-06

This release introduces several quality-of-life refinements to an already stable and featureful package.

Timers can now appear on the modeline

The new minor mode tmr-mode-line-mode controls whether running timers are displayed on the mode line. More specifically, they are displayed in the global-mode-string, which can also be set in the tab-bar-mode (this way the information appears in one place instead of all the mode lines, assuming default settings).

The exact format of a timer on display is controlled by the user option tmr-mode-line-format. The number of timers is set with the option tmr-mode-line-max-timers. The separator between multiple timers is tmr-mode-line-separator. The length of each timer’s optional description is subject to tmr-mode-line-max-desc-length. While the entire indicator can have a prefix, per tmr-mode-line-prefix.

Thanks to Steven Allen for contributing the original version of this feature in pull request 2: https://github.com/protesilaos/tmr/pull/2. Steven has assigned copyright to the Free Software Foundation. Further changes by me, such as to make the timers on the mode line clickable (which produces a tabulated view, per tmr-tabulated-view).

Notifications for more operating systems

Timers can optionally trigger a system notification, via the abnormal hook tmr-timer-finished-functions. The relevant function is tmr-notification-notify. It used to only support Linux. Now it is extended to handle Android, Windows, and Haiku.

Thanks to Lucas Quintana for the contribution in pull request 10: https://github.com/protesilaos/tmr/pull/10. Lucas has assigned copyright to the Free Software Foundation.

The tabulated timers have a “duration” column

The tmr-tabulated-view command (alias tmr-list-timers) now includes a “duration” column, in addition to all the other informative data on display.

[ Remember that the tabulated view can be used to create, duplicate, edit, etc. the timers. ]

Thanks to jpg for suggesting this in issue 11: https://github.com/protesilaos/tmr/issues/11.

Miscellaneous

• System notifications specify the :app-icon of Emacs. It will be displayed, if the underlying software supports it (I see it on Linux, anyway).

• The option to play the tmr-sound-file via the abnormal hook tmr-timer-finished-functions is redone to not rely on the system shell (implicitly bash). This way, users who use exotic shell alternatives will not run into any trouble. This is done in response to a relevant problem that g-gundam was facing with the nushell: https://github.com/protesilaos/tmr/pull/7.

• The function tmr-notification-notify is better at informing the user that it has produced the warning about the lack of DBUS support. Before, the notification did not identity itself as belonging to the tmr package.

• The function tmr-running-timers-p is now available as a standalone function to do what was done before inside other functions. This is useful for anyone writing custom code on top of tmr. Thanks to Eugene Mikhaylov for suggesting the idea in issue 9: https://github.com/protesilaos/tmr/issues/9.

• The manual is updated to include whatever necessary from the aforementioned.

I already mentioned how version 2.0.0 of the ef-themes will be done this way. I am happy to announce that as of this morning the same is true for my standard-themes. Specifically, version 3.0.0 of the Standard themes will be built on top of the modus-themes.

Users are now expected to customise the themes via the user options provided by Modus and to load the themes with the relevant Modus commands. Here is a sample configuration:

(use-package standard-themes
  :ensure t
  :init
  ;; This makes the Modus commands listed below consider only the
  ;; Standard themes.  For an alternative that includes Modus and all
  ;; derivative themes (like Standard), enable the
  ;; `modus-themes-include-derivatives-mode' instead.
  (standard-themes-take-over-modus-themes-mode 1)
  :bind
  (("<f5>" . modus-themes-rotate)
   ("C-<f5>" . modus-themes-select)
   ("M-<f5>" . modus-themes-load-random))
  :config
  ;; All customisations here.
  (setq modus-themes-mixed-fonts t)
  (setq modus-themes-italic-constructs t)

  ;; Finally, load your theme of choice (or a random one with
  ;; `modus-themes-load-random', `modus-themes-load-random-dark',
  ;; `modus-themes-load-random-light').
  (modus-themes-load-theme 'standard-light-tinted))

The modus-themes-theme macro is flexible

This morning, I extended the modus-themes-theme macro to optionally accept custom faces and user options that complement or override those provided by core Modus (the modus-themes-theme macro is documented at length with concrete examples in the aforementioned link to the manual). For the standard-themes, this means that we can inherit all the goodies from Modus but still deviate stylistically in important ways wherever necessary. One case where this is evident is the design of the active mode line: Modus has a flat appearance, while Standard uses a 3D effect.

Standard does not need to deviate substantively from Modus, though there is no technical constraint in this regard. A derivative theme can implement all the requisite deviations to achieve the exact design it aims for, all while reusing Modus.

My plan is to release all new theme versions in the coming days, depending on my availability. Please let me know if you have any questions or want some things to change.

In previous entries, I outlined how my ef-themes will be built on top of my modus-themes and then how the modus-themes are partly redesigned to enable such an arrangement:

• Emacs: the next ‘ef-themes’ will build on top of the ‘modus-themes’ (offers just the big picture view)
• Emacs: building on top of the Modus themes (describes some technicalities)

I have now finalised the details and merged the changes in the respective main branch of each Git repository. If you are building the packages from their latest commit, you might need to delete and then re-install the package. Otherwise, I expect things to work as expected. The modus-themes, in particular, should have no obvious change to its users.

The ef-themes have undergone substantial changes. All of their user options are deprecated and will no longer have any effect. User options from the Modus themes now take their place. Furthermore, all the Ef commands to load a theme are discontinued. The plan is to re-use the infrastructure of the Modus themes throughout. Concretely, users must change their configuration to at least this minimal setup:

(use-package ef-themes
  :init
  ;; This is essential to let the Ef themes take over the Modus themes commands.
  (ef-themes-take-over-modus-themes-mode 1))

Or this sort, if they want some key bindings and customisations:

(use-package ef-themes
  :init
  (ef-themes-take-over-modus-themes-mode 1)
  :bind
  (("<f5>" . modus-themes-rotate)
   ("C-<f5>" . modus-themes-select)
   ("M-<f5>" . modus-themes-load-random))
  :config
  ;; All customisations here.
  (setq modus-themes-mixed-fonts t))

Load a theme

The commands modus-themes-rotate, modus-themes-select, modus-themes-toggle, and modus-themes-load-random will also load a theme interactively.

Loading a specific theme from Lisp works as expected:

(load-theme 'ef-cyprus :no-confirm)

To do the same while also triggering the modus-themes-after-load-theme-hook as well as the modus-themes-disable-other-themes:

(modus-themes-load-theme 'ef-summer)

To load a theme at random, do this:

(modus-themes-load-random)
(modus-themes-load-random 'dark) ; dark only (alternative `modus-themes-load-dark')
(modus-themes-load-random 'light) ; light only (alternative `modus-themes-load-light')

Use both Ef and Modus themes

To not take over the Modus themes completely and to instead allow the Modus commands to act on both Modus and Ef themes, enable this minor mode instead:

(modus-themes-include-derivatives-mode 1)

And make sure you disable ef-themes-take-over-modus-themes-mode in this case.

More customisation for the Ef themes

All the user options of the Modus themes are now available. For example, there was no option in the past to disable bold and italic styles from the Ef themes. They are now disabled by default, unless the user sets modus-themes-bold-constructs and modus-themes-italic-constructs to non-nil values.

Additionally, the Ef themes now enjoy wider face/package support.

Everything else should be as expected

Advanced users who were relying on the ef-themes-with-colors or any other Ef functionality will have to do the same with the Modus framework. Everything is possible, plus I am happy to help with the transition if you have any questions.

The Modus themes benefit from this redesign because their code is made to be more generic and to not hardcode certain assumptions. It also makes sense for them to be useful as a dependency for other themes, as they are part of core Emacs, which is convenient.

Remember that everything is still in development. I will expand the manuals and make sure everything is in order for the next major version of each of these two projects.

If everything goes well, expect my standard-themes to be redone on top of the modus-themes. But not for the doric-themes: those are quite different in style and overall design.

In this article, I give you the big picture view of how this is supposed to work. Remember that the only source of truth for my packages is their corresponding manual. Any blog post is useful the time it is written but will eventually go out of date.

Symbol properties for themes

When we define a theme, we essentially add properties to a symbol. In its simplest form, this is how:

(put 'my-test-symbol 'my-test-proerty "Hello world test value")

Evaluate the above and then try the following:

(get 'my-test-symbol 'my-test-proerty)
;; => "Hello world test value"

The function custom-declare-theme does the heavy lifting, while the deftheme macro streamlines most of that work. Still, the point is that we have symbols whose properties we can access and, thus, we can filter by any given property. To make things even better, we can add arbitrary properties to a theme. Here is a real scenario of _in-development code that might change:

(get 'modus-operandi 'theme-properties)
;; => (:kind color-scheme :background-mode light :family modus-themes :modus-core-palette modus-themes-operandi-palette :modus-user-palette modus-operandi-palette-user :modus-overrides-palette modus-operandi-palette-overrides)

The theme-properties has as a plist value. Its Modus-specific properties are references to variables that we can use to do our work, such as to put together a theme palette that combines the relevant overrides with the core entries.

Getting a list of themes based on their properties

When we declare a theme with custom-declare-theme, we make it known to Emacs by adding it to the custom-known-themes. When we eventually load a theme, its symbol gets stored in the custom-enabled-themes. Knowing that themes have properties, we can filter those lists accordingly. With my current development code, I can do this, for example:

(defun my-demo-is-modus-p (theme)
  "Return non-nil if THEME has `modus-themes' :family property."
  (when-let* ((properties (get theme 'theme-properties))
              (family (plist-get properties :family)))
    (eq family 'modus-themes)))

(seq-filter #'my-demo-is-modus-p custom-known-themes)
;; => (modus-vivendi-tritanopia modus-vivendi-tinted modus-vivendi modus-vivendi-deuteranopia modus-operandi-tritanopia modus-operandi-tinted modus-operandi modus-operandi-deuteranopia)

The next step from here is to make all the Modus infrastructure rely on generic functions and methods for working with themes. Then any package can provides its own method for returning a list of desired themes.

Generic function and methods for getting a list of themes

Emacs Lisp has a concept of generic functions, which it borrows from Common Lisp. The general idea is to have a single symbol, like modus-themes-get-themes whose implementation details are instantiated via specialised methods. For example, when a minor mode is active, a given method takes effect, thus changing what modus-themes-get-themes actually does.

The default implementation is this:

(cl-defgeneric modus-themes-get-themes ()
  "Return a list of all themes with `modus-themes' :family property."
  (modus-themes-get-all-known-themes 'modus-themes))

The function modus-themes-get-all-known-themes has a filter like the one I demonstrated in the code block further above. By default, this is what I get when I run the aforementioned generic function:

(modus-themes-get-themes)
;; => (modus-operandi modus-operandi-tinted modus-operandi-deuteranopia modus-operandi-tritanopia modus-vivendi modus-vivendi-tinted modus-vivendi-deuteranopia modus-vivendi-tritanopia)

The beauty of this design is that another package can define a method to make the same code return something else. This is how I do it in the current development target of the ef-themes (again, the actual code might change):

(cl-defmethod modus-themes-get-themes (&context (ef-themes-take-over-modus-themes-mode (eql t)))
  (modus-themes-get-all-known-themes 'ef-themes))

Notice that this method has a &context, which is the scenario in which it is relevant. In this case, we have a minor mode that activates the method when it is enabled:

(define-minor-mode ef-themes-take-over-modus-themes-mode
  "When enabled, all Modus themes commands consider only Ef themes."
  :global t
  :init-value nil)

This minor mode does not have anything in its body. It does not need to, because the define-minor-mode macro already instantiates the parts we care about. Namely, when we call the function defined by the minor mode (i.e. ef-themes-take-over-modus-themes-mode), it toggles the value of the variable ef-themes-take-over-modus-themes-mode (functions and variables have separate namespaces in Emacs Lisp and thus the same symbol can be in both places). Our method then becomes relevant when the user enables the minor mode:

(ef-themes-take-over-modus-themes-mode 1)

And now the generic function modus-themes-get-themes does something else:

(modus-themes-get-themes)
;; => (ef-winter ef-tritanopia-light ef-tritanopia-dark ef-trio-light ef-trio-dark ef-symbiosis ef-summer ef-spring ef-rosa ef-reverie ef-owl ef-night ef-melissa-light ef-melissa-dark ef-maris-light ef-maris-dark ef-light ef-kassio ef-frost ef-elea-light ef-elea-dark ef-eagle ef-duo-light ef-duo-dark ef-dream ef-deuteranopia-light ef-deuteranopia-dark ef-day ef-dark ef-cyprus ef-cherie ef-bio ef-autumn ef-arbutus)

Since all the Modus functions are redesigned to work with this generic function, we can now use commands like modus-themes-select or even modus-themes-list-colors for any of those themes.

As a bonus, we can now seamlessly blend Modus themes with their derivatives. Imagine a user who wants to invoke the command modus-themes-load-random (or its variants for light and dark themes) and have it consider the likes of modus-operandi and ef-dream. Users can opt in to this feature via the minor mode that the Modus themes provide called modus-themes-include-derivatives-mode. It is the same ideas as the minor mode for the Ef themes, mentioned above:

(define-minor-mode modus-themes-include-derivatives-mode
  "When enabled, all Modus themes commands cover derivatives as well.
Otherwise, they only consider the `modus-themes-items'.

Derivative theme projects can implement the equivalent of this minor
mode plus a method for `modus-themes-get-themes' to filter themes
accordingly."
  :global t
  :init-value nil)

(cl-defmethod modus-themes-get-themes (&context (modus-themes-include-derivatives-mode (eql t)))
  (modus-themes-get-all-known-themes nil))

This is what happens when I load both the modus-themes and the ef-themes and enable this “all good ones fit” minor mode:

(modus-themes-include-derivatives-mode 1)

(modus-themes-get-themes)
;; => (modus-operandi modus-operandi-tinted modus-operandi-deuteranopia modus-operandi-tritanopia modus-vivendi modus-vivendi-tinted modus-vivendi-deuteranopia modus-vivendi-tritanopia ef-winter ef-tritanopia-light ef-tritanopia-dark ef-trio-light ef-trio-dark ef-symbiosis ef-summer ef-spring ef-rosa ef-reverie ef-owl ef-night ef-melissa-light ef-melissa-dark ef-maris-light ef-maris-dark ef-light ef-kassio ef-frost ef-elea-light ef-elea-dark ef-eagle ef-duo-light ef-duo-dark ef-dream ef-deuteranopia-light ef-deuteranopia-dark ef-day ef-dark ef-cyprus ef-cherie ef-bio ef-autumn ef-arbutus)

And when I no longer want to include everything, I just disable the minor mode:

(modus-themes-include-derivatives-mode -1)

(modus-themes-get-themes)
;; => (modus-operandi modus-operandi-tinted modus-operandi-deuteranopia modus-operandi-tritanopia modus-vivendi modus-vivendi-tinted modus-vivendi-deuteranopia modus-vivendi-tritanopia)

It is a thing of beauty!

Finalising the implementation details

I am still experimenting with some of the technicalities involved. In principle, derivative themes will (i) depend on the modus-themes, (ii) define each of their themes using the modus-themes-theme macro, and (iii) specify how/when they affect the behaviour of the generic function modus-themes-get-themes.

The code I am working on will soon be available in the respective main branch of modus-themes.git and ef-themes.git. I think this gives us the tools to realise the full potential of the Modus themes.

Finally, it is not just package authors that can benefit from this development. Users may also curate their themes with something as basic as this:

(cl-defmethod modus-themes-get-themes ()
  '(modus-operandi ef-eagle modus-vivendi-tinted ef-melissa-dark))

(modus-themes-get-themes)
;; => (modus-operandi ef-eagle modus-vivendi-tinted ef-melissa-dark)

In this method, there is no function involved for returning a list of themes nor an opt-in clause. It simply hardcodes a list of themes. The point is that it works! The approach with the minor mode will usually be better and is easy enough. It is all a matter of empowering personal preference, which is the Emacs-y outlook, after all. I expect users to define their own collections, as they see fit.

Have fun!

About the Modus themes

Highly accessible themes, conforming with the highest standard for colour contrast between background and foreground values (WCAG AAA). They also are optimised for users with red-green or blue-yellow colour deficiency.

The themes are very customisable and provide support for a wide range of packages. Their manual is detailed so that new users can get started, while it also provides custom code for all sorts of more advanced customisations.

Since August 2020, the original Modus themes (modus-operandi, modus-vivendi) are built into Emacs version 28 or higher. Emacs 28 ships with modus-themes version 1.6.0. Emacs 29 includes version 3.0.0. Emacs 30 provides version 4.4.0. Version 4 is a major refactoring of how the themes are implemented and customised. Such major versions are not backward-compatible due to the limited resources at my disposal to support multiple versions of Emacs and of the themes across the years.

• Package name (GNU ELPA): modus-themes
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

About the Ef themes

The ef-themes are a collection of light and dark themes for GNU Emacs that provide colourful (“pretty”) yet legible options for users who want something with a bit more flair than the modus-themes (also designed by me).

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

When I first designed the ef-themes, Modus did not have the aforementioned capabilities. As such, Ef had to be implemented from scratch. Over time, the two projects have converged in terms of overall approach. There still are some notable differences, namely, Ef is less customisable and extensive than Modus. This is about to change.

I am working on a thoroughgoing redesign of the Ef themes to make them essentially load either modus-operandi (main light theme) or modus-vivendi (main dark theme) with the relevant palette overrides. All the Ef themes will look the same as they do now, but under the hood things will become much simpler. What is currently a standalone “theme” object will be reduced to a palette definition, essentially an alist.

In a future publication, I will document all the breaking changes. In short, all customisation shall be done via the Modus user options. Ef will only implement its palettes. As for my doric-themes and standard-themes those will remain unchanged for the time being. Standard might go the way of Ef, but Doric will probably continue to be its own thing. At any rate, these issues will be examined when their time is right.

Stay tuned for more. In the meantime, enjoy version 1.11.0 of the Ef themes that I released earlier this week!

About the Ef themes

The ef-themes are a collection of light and dark themes for GNU Emacs that provide colourful (“pretty”) yet legible options for users who want something with a bit more flair than the modus-themes (also designed by me).

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

About the Modus themes

Highly accessible themes, conforming with the highest standard for colour contrast between background and foreground values (WCAG AAA). They also are optimised for users with red-green or blue-yellow colour deficiency.

The themes are very customisable and provide support for a wide range of packages. Their manual is detailed so that new users can get started, while it also provides custom code for all sorts of more advanced customisations.

Since August 2020, the original Modus themes (modus-operandi, modus-vivendi) are built into Emacs version 28 or higher. Emacs 28 ships with modus-themes version 1.6.0. Emacs 29 includes version 3.0.0. Emacs 30 provides version 4.4.0. Version 4 is a major refactoring of how the themes are implemented and customised. Such major versions are not backward-compatible due to the limited resources at my disposal to support multiple versions of Emacs and of the themes across the years.

• Package name (GNU ELPA): modus-themes
• Official manual: https://protesilaos.com/emacs/modus-themes
• Change log: https://protesilaos.com/emacs/modus-themes-changelog
• Colour palette: https://protesilaos.com/emacs/modus-themes-colors
• Sample pictures: https://protesilaos.com/emacs/modus-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/modus-themes
  • GitLab: https://gitlab.com/protesilaos/modus-themes
• Backronym: My Old Display Unexpectedly Sharpened … themes.

• Package name (GNU ELPA): ef-themes
• Official manual: https://protesilaos.com/emacs/ef-themes
• Change log: https://protesilaos.com/emacs/ef-themes-changelog
• Sample pictures: https://protesilaos.com/emacs/ef-themes-pictures
• Git repositories:
  • GitHub: https://github.com/protesilaos/ef-themes
  • GitLab: https://gitlab.com/protesilaos/ef-themes
• Backronym: Eclectic Fashion in Themes Hides Exaggerated Markings, Embellishments, and Sparkles.

Below are the release notes.

Version 1.11.0 on 2025-09-25

This version introduces minor refinements to a stable package.

Support for faces added to Emacs 31

Emacs 31 is the current development target of Emacs. The new faces are header-line-inactive, package-mark-delete-face, package-mark-install-face, minibuffer-nonselected.

Mode lines are a bit easier to spot

The active and inactive mode lines now have a subtle box/border around them on graphical Emacs. In non-graphical sessions, an underline is applied instead. This makes mode lines easier to stand out even when the buffer is showing a background that is of a similar colour to their own background.

The Custom interface buttons are more refined

These are the buttons that appear in the Custom buffers that we reach through various means such as M-x customize. Like with the mode lines, they use a box/border around where possible, else fall back to an underline.

The current date in the M-x calendar always looks the same

Before, it would look different if the Calendar was produced via M-x calendar as opposed to the Org date selection interface. This is because they apply different faces to the current date. Those are now reworked to look the same.

Notmuch message summary headers have clear dividers

In the Notmuch email client, the messages in a thread can be collapsed/minimised to just a heading. Those used to have only a subtle background, which would be enough to differentiate them from the body of the email but not from each other when all were collapsed. Now the themes add an overline to each heading, if supported by the underlying display engine (i.e. graphical Emacs), which should make it easier to spot them.

Links in the header line of Info buffers do not have an underline

This is because the header line has a distinct background already, so we want to avoid exaggerations.

The commands ef-themes-rotate and ef-themes-load-random can be silent

They now accept an optional SILENT parameter that inhibits the message they otherwise print. Thanks to Sean Devlin for the contribution in pull request 59: https://github.com/protesilaos/ef-themes/pull/59.

Note that any function can be silenced with something like this:

(defun my-wrapper-of-some-function ()
  (let ((inhibit-message t))
    (some-function)))

The default Denote identifier is a compact representation of the date and time, with the letter T in between. For example:

20250924T190920

The letter T does not have any special meaning. It simply delimits the two constituents of the identifier. Users who want to record the day of the week can ultimately derive identifiers that look like these:

20250922A082941
20250923B140652
20250924C191038

And with some spaces for didactic purposes:

2025 09 22   A   08 29 41
2025 09 23   B   14 06 52
2025 09 24   C   19 10 38

[ Actually, users can produce identifiers with such spaces, but I will leave this as an exercise for interested parties. ]

Get the day of the week as a capital letter

To get the day of the week as a string that holds a number, we use the %u format specifier of the function format-time-string. Today is Wednesday, thus:

(format-time-string "%u")
;; => "3"

Based on this, we know that we need a function that takes such a string and returns the corresponding capital letter. Here is one way of achieving as much:

(defun my-denote-get-day-of-week-as-alpha (day)
  "Return the corresponding capital letter for DAY.
DAY is a string holding a number, as the return value of the %u
specifier in `format-time-string'.

If DAY is a number, convert it to a string and then return its
corresponding letter."
  (pcase (if (numberp day) (number-to-string day) day)
    ("1" "A")
    ("2" "B")
    ("3" "C")
    ("4" "D")
    ("5" "E")
    ("6" "F")
    ("7" "G")
    (_ (error "The day `%S' is not among 1-7" day))))

The pcase macro does the heavy lifting here. We basically test for string equality and return a new string or throw an error. Testing the code, I get these results:

(my-denote-get-day-of-week-as-alpha "3")
;; => "C"

(my-denote-get-day-of-week-as-alpha 3)
;; => "C"

(my-denote-get-day-of-week-as-alpha "10")
;; => ERROR

(my-denote-get-day-of-week-as-alpha 10)
;; => ERROR

Tweak the Denote identifier format to pass the %u specifier

Denote stores the format-time-string specifiers for its default identifier in the variable denote-date-identifier-format. The value is "%Y%m%dT%H%M%S", which is what derives the aforementioned standard identifier.

We already noted that we do not want that literal T over there. So let us make our format the same as the original one except that we include %u in place of T. A function call that would yield the desired result is this:

(replace-regexp-in-string "T" " %u " denote-date-identifier-format t)
;; => "%Y%m%d %u %H%M%S"

Notice that I add a space before and after the %u. These are delimiters that we will use to split the string more easily into its DATE, DAY, TIME components. But one step at a time. We first need to define this as a variable:

[ Technically, this is not a normal variable because of defconst instead of the more common defvar, but we do not need to consider such details. ]

(defconst my-denote-date-identifier-format
  (replace-regexp-in-string "T" " %u " denote-date-identifier-format t))

Format a date using the new identifier scheme

Our next task is to write a small function that takes a date argument and returns a string whose pattern follows what we did in the previous section. For example, if the current date is 2025-09-24, the day is Wednesday, and the time is 19:30:00, we expect an identifier like 20250924C193000.

To keep things simple, we will not go into how Emacs represents dates internally. It does not matter, anyway, because Denote handles that part internally. All we need to test our function is to use the return value of the function current-time. Actually, even that is optional because format-time-string defaults to that if it is not given an explicit date as an argument.

As such, here is how we get the string "DATE DAY TIME", based on what we have:

(format-time-string my-denote-date-identifier-format)
;; => "20250924 3 193347"

Remember those spaces from earlier? We need them now to split this string into a list of three strings, so that we can isolate the day in the middle. Once we have just the day, we can pass it to the function we wrote earlier that gives us the corresponding capital letter.

To split a string at the spaces, we do this (read the split-string doc string for further details):

(split-string STRING)

Which means:

(split-string (format-time-string my-denote-date-identifier-format))
;; => ("20250924" "3" "193626")

We get back a list of strings, so the day is retrieved thus:

(nth 1 '("20250924" "3" "193626"))
;; => "3"

Use (nth 0 ...) for the date and (nth 2 ...) for the time.

Now that we know all this, we can piece it together into a single function. Here is what we will do, which I shall explain in further detail below:

(defun my-denote-format-date (date)
  "Format DATE using `my-denote-date-identifier-format'.
Represent the day of the week with `my-denote-get-day-of-week-as-alpha'."
  (pcase-let* ((identifier-string (format-time-string my-denote-date-identifier-format date))
               (`(,date ,day ,time) (split-string identifier-string))
               (day-as-letter (my-denote-get-day-of-week-as-alpha day)))
    (concat date day-as-letter time)))

The pcase-let* macro uses “destructuring” to pattern match the return value and bind it to the variables we name (also see my free (gratis and libre) book: Emacs Lisp Elements). This is the short way of doing the following:

(defun my-denote-format-date (date)
  "Format DATE using `my-denote-date-identifier-format'."
  (let* ((identifier-string (format-time-string my-denote-date-identifier-format date))
         (strings (split-string identifier-string))
         (date (nth 0 strings))
         (day (nth 1 strings))
         (time (nth 2 strings))
         (day-as-letter (my-denote-get-day-of-week-as-alpha day)))
    (concat date day-as-letter time)))

Use whichever style you prefer.

The point is that we (i) take the return value of format-time-string with the spaces, as I showed above, (ii) split it at the spaces into three strings, (iii) assign each of those strings to a variable local to this function, (iv) convert the day from a number to a capital letter, and (v) put it all back together without those spaces. The result is this:

(my-denote-format-date (current-time))
;; => "20250924C194219"

Write and then use the custom denote-get-identifier-function

The variable denote-get-identifier-function has the symbol of a function as its value. Its documentation describes the technicalities. Though, again, we do not need to understand the finer points to achieve our goal. Since our custom identifier is almost the same as the default, we can copy the original function that Denote relies on and make a small change to it so that it uses the my-denote-format-date we just wrote. Behold:

(defun my-denote-generate-identifier-as-date (initial-identifier date)
  "Generate an identifier based on DATE.

If INITIAL-IDENTIFIER is not already used, return it.  Else, if it is
possible to derive an identifier from it, return this identifier.

Else, use the DATE.  If it is nil, use `current-time'.

Slightly modified version of `denote-generate-identifier-as-date'."
  (let ((denote-used-identifiers (or denote-used-identifiers (denote--get-all-used-ids))))
    (cond ((and initial-identifier
                (not (gethash initial-identifier denote-used-identifiers)))
           initial-identifier)
          ((and initial-identifier
                (string-match-p denote-date-identifier-regexp initial-identifier)
                (date-to-time initial-identifier))
           (denote--find-first-unused-id-as-date initial-identifier))
          (t
           (denote--find-first-unused-id-as-date
            (my-denote-format-date (or date (current-time))))))))

The internal workings do not matter right now, though I am happy to explain them elsewhere. Our priority is to find where my-denote-format-date is used. The only difference between what we have here and the original is that our final line uses my-denote-format-date, while the original does a format-time-string with the denote-date-identifier-format (which we saw further above when we replaced T with %u).

Finally, bind denote-get-identifier-function to the symbol of the custom function to start using it:

(setq denote-get-identifier-function #'my-denote-generate-identifier-as-date)

All Denote files will henceforth look like this:

@@20250924C190301--this-is-a-test__denote_testing.txt

Remember that the @@ exists for custom identifiers and that all the components of the file name can be reordered.

This covers it! The manual has more examples and I always am eager to help anyone who needs to do something a little bit differently.

About Denote

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

[ I have a page with all my Emacs packages, which includes all the Denote extensions I maintain: https://protesilaos.com/emacs. ]

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

By default, Denote constructs a file name to have, at minimum, an identifier as a compact representation of the date and time. It looks like this: 20250920T120924. The default file will also have a title and keywords, based on user input at the relevant minibuffer prompts, so it will look like this:

20250920T120924--denote-custom-identifiers__emacs_programming.txt

Instead of hardcoding the scheme of an identifier as a compact representation of a date and time, we provide the variable denote-get-identifier-function. Its value is the symbol of a function, which is called to yield an identifier, as a string.

I have written a few examples of this in the Denote manual, grouped under this section: https://protesilaos.com/emacs/denote#h:3048f558-7d84-45d6-9ef2-53055483e801. Read the documentation of denote-get-identifier-function for the remaining technicalities.

The identifier can be anything from an automatic incremental numbering scheme to something that always asks for user input to produce a more information-dense result. To illustrate the potential of the latter concept, the manual elaborates on the use-case of recording data about academic publications, such as the editor, authors, and publisher, through a series of minibuffer prompts. The end result is a unique identifier with the help of some extra helper functions.

Custom identifiers are prefixed with the @@ file name component separator. This way they are unambiguous and can be retrieved with certainty. More so since the Denote file name components can be presented in any order, per the user option denote-file-name-components-order.

Custom identifiers are the culmination of many changes over the years to make the Denote file-naming scheme as flexible as possible. It is super effective out-of-the-box and can then be particularised to specific workflows with ease. These are not mutually exclusive, as users can still rely on the regular Denote functionality for most cases and only deviate from it with bespoke functions where necessary. For instance, to have a special variant of denote-rename-file that applies a custom identifier scheme instead of the default, users can write a wrapper command like this:

(defun my-denote-rename-file-with-my-custom-identifier ()
  "Like `denote-rename-file' but use `my-denote-get-custom-identifier' instead."
  (interactive)
  (let ((denote-get-identifier-function #'my-denote-get-custom-identifier))
    (call-interactively 'denote-rename-file)))

Imagine doing this for files in a specific folder where the standard identifier provided by Denote does not add much value (beside being a unique match for the linking mechanism, that is).

The Denote manual is full of examples like the above. These sort of small and elegant extensions are possible owning to the design of the code into easily adaptable functions.

We keep going from strength to strength and I am delighted with the results. I hope you make good use of the tools on offer. Let me know if there is anything more you need: I am confident we can make it happen.

Much of the thought and work that went is to this project is thanks to user mentalisttraceur and long-time contributor Jean-Philippe Gagné Guay.

About Denote

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

[ I have a page with all my Emacs packages, which includes all the Denote extensions I maintain: https://protesilaos.com/emacs. ]

• Package name (GNU ELPA): denote
• Official manual: https://protesilaos.com/emacs/denote
• Change log: https://protesilaos.com/emacs/denote-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/denote
  • GitLab: https://gitlab.com/protesilaos/denote
• Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
• Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

• Prompt for a font on the system and display it in a buffer.
• List all known fonts in a buffer, with a short preview for each.
• Provide a major mode to preview a font whose file is among the installed ones.

Sources:

• Package name (GNU ELPA): show-font
• Official manual: https://protesilaos.com/emacs/show-font
• Change log: https://protesilaos.com/emacs/show-font-changelog
• Git repository: https://github.com/protesilaos/show-font
• Sample pictures: https://protesilaos.com/codelog/2024-09-10-emacs-show-font-0-1-0/
• Backronym: Should Highlight Only With the Family Of the Named Typeface.

Below are the release notes.

Version 1.0.0 on 2025-09-07

This major update introduces support for fonts that cover more than the Latin script. It also expands the available functionality with quality-of-life refinements.

Support for Arabic, Chinese, Greek, Japanese, Korean, Russian

The commands show-font-tabulated (alias show-font-list) and show-font-select-preview can now generate a preview for fonts that are optimised to display the aforementioned languages. Each language provides its own user option to control the sample text it displays. The naming pattern show-font-LANGUAGE-sample.

Of those, I only know Greek and thus wrote the value of show-font-greek-sample, namely: "Πρωτεσίλαος ο φιλόσοφος του οποίου τα έργα βρίθουν αστειισμών". For the others I used translation software to get the equivalent of "Protesilaos does not read LANGUAGE". Please let me know if there are any mistakes in this regard. I was thinking of writing something a bit more funny, but was concerned the joke may not translate well.

Checking for language support among known families

While I have written functions that test if a given font can display a range of characters, this approach is computationally intensive if we need to check for many code points across multiple fonts.

The alternative is to maintain lists of known font families that are meant to work with the given language. Those generally support Latin as well, but the idea is to let them shine in the language they are meant to be used for.

For example, here is how we know that a font family is meant to display Arabic script:

(defconst show-font-arabic-families
  '("AlArabiya" "AlBattar" "AlHor" "AlManzomah" "AlYarmook"
    "Dimnah" "Hani" "Haramain" "Hor" "Kayrawan" "Khalid" "Mashq"
    "Nagham" "Noto Kufi Arabic" "Noto Naskh Arabic" "Noto Sans Arabic"
    "Rehan" "Sharjah" "Sindbad")
  "List of families that specialise in Arabic.
Also see `show-font-greek-families' for the rationale of grouping font
families in distinct variables.")

The list is not exhaustive and I am always eager to expand it. Just let me know.

I learnt about these font families through trial and error by (i) installing them on my Debian system and (ii) searching online for common samples of them. Do apt search -n fonts- to check the relevant packages.

Support for music notation, mathematics, and other symbols

As with the natural languages, there are some fonts that specialise in displaying symbols. For example, MathJax has a bunch of fonts for showing those fancy formulas in the processed output of LaTeX documents. Again, there is a defconst for each of those types of font listing the known families. The concomitant user options are:

• show-font-mathematics-sample
• show-font-music-sample
• show-font-symbols-sample

Problematic fonts are hidden from the list view

The show-font-hidden-families lists the fonts that are not known to cause problems. They do not render properly any of the supported samples and I am not sure even when they claim to support a certain set of characters (e.g. show-font--displays-latin-p returns non-nil). If you think there is a mistake here, please contact me.

Show a full preview from the list view

While in the buffer produced by show-font-tabulated (alias show-font-list), type RET to get a complete preview of the font family of the current line. This is the same as invoking the command show-font-select-preview and then selecting the given family.

The command called by that key binding is show-font-tabulated-select-preview. A hint of it is also shown in the tabulated list header.

Quickly copy the name of the font in the list view

As above, type w in the tabulated view to copy the name of the font family to the kill-ring. The command is show-font-tabulated-copy-name and there is also a hint of it in the tabulated list header.

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.

Update to doric-themes version 0.4.0

This version brings several refinements to the package, as well as two new themes.

Enjoy doric-beach and doric-valley

Most of the Doric themes feel monochromatic. By contrast, the doric-beach (light) and doric-valley (dark) are dichromatic: they combine warm hues, such as orange, with cold hues like teal. They still are minimalistic, like the rest of the family, but appear a bit more playful than their more austere counterparts.

[ The doric-oak and doric-pine are similar in this regard. ]

Refashioned diffs

All diff interfaces, including Magit, diff-mode, and Ediff now rely on a comprehensive new subset of colours. They use colour-coded backgrounds throughout, whereas before they had just colour-coded text. The problem with highlighting only text is that it is harder to (i) discern the colour and thus (ii) quickly estimate the boundaries of a change.

For Magit in particular, there are distinct styles for the highlighted/current diff hunk, all other diff hunks, as well as the common word-wise (“refined”) diffs that all interfaces share.

Org agenda and dates are more consistent

The changes here are subtle but should contribute to a more pleasant experience, owning to the more careful emphasis of information. “Scheduled” entries are easier to notice, as they are distinct from other events. Date headings also have a more clear distinction from the tasks they contain.

For the M-x calendar, in particular, month and date headings are revised to be consistent with the Org agenda, while the diary and holiday faces are redone to look harmonious in context. Thanks to Amin Bandali for checking those and suggesting some tweaks.

Certain header-like faces stand out more

In various contexts, such as in git-mode commit message comments or Dired buffers, there are pieces of text that conceptually are headings. Those are rendered in a distinct style than other generic “bold” faces, to better perform their function.

Flymake fringe indicators are easier to spot

Those now have a fine background colour, coded to the type of warning.

Support for the lin and pulsar packages

Those define faces that affect the background of a line. These packages now feel right when used in tandem with the doric-themes.

• Prompt for a font on the system and display it in a buffer.
• List all known fonts in a buffer, with a short preview for each.
• Provide a major mode to preview a font whose file is among the installed ones.

Sources:

• Package name (GNU ELPA): show-font
• Official manual: https://protesilaos.com/emacs/show-font
• Change log: https://protesilaos.com/emacs/show-font-changelog
• Git repository: https://github.com/protesilaos/show-font
• Sample pictures: https://protesilaos.com/codelog/2024-09-10-emacs-show-font-0-1-0/
• Backronym: Should Highlight Only With the Family Of the Named Typeface.

Below are the release notes.

Version 0.4.0 on 2025-08-26

This version expands the capabilities of the font preview mechanism to handle emoji and icon fonts (i.e. those with codepoints in the Unicode Private Use Area).

Both the show-font-select-preview and show-font-tabulated commands now handle these types of font.

Previews for emoji or icon fonts are done using the string of characters set to the variable show-font-emoji-sample or show-font-icon-sample. These symbols are user options.

Coming in version 0.4.0

The character of the themes is well-defined, though I may still make some small tweaks. Expect these and other improvements to be available in the next stable version of the doric-themes, which I expect to publish some time before the end of August.

About the Doric themes

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.

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

1.2.0 on 2025-08-14

The package is stable and gets the job done. This version introduces a small new feature to restart the daemon from inside Emacs. Thanks to Jonathan Neidel for making the suggestion in issue 1: https://github.com/protesilaos/sxhkdrc-mode/issues/1.

Reload the SXHKD daemon on demand

The command sxhkdrc-mode-restart sends a signal to the sxhkd process which causes it to restart, thus reloading its configuration file. Use this after modifying the sxhkdrc to make the new changes available.

Automatically reload the daemon on file save

The function sxhkdrc-mode-auto-restart can be assigned to the sxhkdrc-mode-hook to automatically reload the daemon after the sxhkdrc file is saved (well, technically, after the file which is using the sxhkdrc-mode is saved).

Sample configuration with use-package

The project’s README.md includes this sample configuration:

(use-package sxhkdrc-mode
  :ensure t
  :mode "sxhkdrc.*" ; if you want more than just "sxhkdrc"
  :commands (sxhkdrc-mode-restart)
  :hook (sxhkdrc-mode . sxhkdrc-mode-auto-restart))

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.

The new oak and pine themes

These explore the woody+earthly style:

• doric-oak has dark text against an ochre background, with accents of green.

• doric-pine uses light text against a dark green background, with accents of brown.

Background colours for diffs

All diff-related interfaces, including Magit, diff-mode, and Ediff, now use colour-coded background values where appropriate. This is done to improve usability, as it otherwise can be hard to discern the boundaries of individual diff hunks.

Alternating foreground values for message/email quotes

In message-mode, Gnus, and related interfaces all quoted/cited message level now conforming with an odd VS even colouring scheme. The style is still subtle, but now the individual levels of depths are easier to spot.

This morning, I got the paperback version of the book. It is a thing of beauty!

Thanks to Peter for working on this and for showing how Emacs can also be used as a professional publishing tool.

Emacs Writing Studio sources

Buy the book, check the source code, and watch the videos:

• Payhip: https://payhip.com/b/alhIJ
• e-readers: https://books2read.com/u/4NpgQ9?format=ebook
• Paperback: https://books2read.com/u/4NpgQ9?format=print
• LeanPub: https://leanpub.com/emacswritingstudio
• GitHub: https://github.com/pprevos/emacs-writing-studio/
• YouTube: https://www.youtube.com/playlist?list=PLGx4TR_jvOQDIT878vGDe1ElUlij3UEKI

Also read the Why Use Emacs essay on Peter’s website: https://lucidmanager.org/productivity/why-use-emacs/.

I may still make further refinements, though the character of the themes is set. Once I am done, I will publish them as part of version 0.3.0 of the package.

About the Doric themes

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.