neocaml 0.1 is finally out! Almost a year after I announced the project, I’m happy to report that it has matured to the point where I feel comfortable calling it ready for action. Even better - neocaml recently landed in MELPA, which means installing it is now as easy as:

1
M-x package-install <RET> neocaml <RET>

That’s quite the journey from “a fun experimental project” to a proper Emacs

Why neocaml?

You might be wondering what’s wrong with the existing options. The short answer - nothing is wrong per se, but neocaml offers a different set of trade-offs:

• caml-mode is ancient and barely maintained. It lacks many features that modern Emacs users expect and it probably should have been deprecated a long time ago.
• tuareg-mode is very powerful, but also very complex. It carries a lot of legacy code and its regex-based font-locking and custom indentation engine show their age. It’s a beast - in both the good and the bad sense of the word.
• neocaml aims to be a modern, lean alternative that fully embraces TreeSitter. The codebase is small, well-documented, and easy to hack on. If you’re running Emacs 29+ (and especially Emacs 30), TreeSitter is the future and neocaml is built entirely around it.

Of course, neocaml is the youngest of the bunch and it doesn’t yet match Tuareg’s feature completeness. But for many OCaml workflows it’s already more than sufficient, especially when combined with LSP support. package! Let me now walk you through the highlights of version 0.1.

Features

The current feature-set is relatively modest, but all the essential functionality one would expect from an Emacs major mode is there.

TreeSitter-powered Syntax Highlighting

neocaml leverages TreeSitter for syntax highlighting, which is both more accurate and more performant than the traditional regex-based approaches used by caml-mode and tuareg-mode. The font-locking supports 4 customizable intensity levels (controlled via treesit-font-lock-level, default 3), so you can pick the amount of color that suits your taste.

Both .ml (source) and .mli (interface) files get their own major modes with dedicated highlighting rules.

TreeSitter-powered Indentation

Indentation has always been tricky for OCaml modes, and I won’t pretend it’s perfect yet, but neocaml’s TreeSitter-based indentation engine is already quite usable. It also supports cycle-indent functionality, so hitting TAB repeatedly will cycle through plausible indentation levels - a nice quality-of-life feature when the indentation rules can’t fully determine the “right” indent.

If you prefer, you can still delegate indentation to external tools like ocp-indent or even Tuareg’s indentation functions. Still, I think most people will be quite satisfied with the built-in indentation logic.

Navigation and Imenu

neocaml provides proper structural navigation commands (beginning-of-defun, end-of-defun, forward-sexp) powered by TreeSitter, plus imenu integration with language-specific categories for both .ml and .mli files. Jumping to definitions in a buffer has never been easier.

REPL Integration

No OCaml mode would be complete without REPL (toplevel) integration. neocaml-repl-minor-mode provides all the essentials:

• C-c C-z - Start or switch to the OCaml REPL
• C-c C-c - Send the current definition
• C-c C-r - Send the selected region
• C-c C-b - Send the entire buffer
• C-c C-p - Send a phrase (code until ;;)

The default REPL is ocaml, but you can easily switch to utop via neocaml-repl-program-name.

I’m still on the fence on whether I want to invest time into making the REPL-integration more powerful or keep it as simple as possible. Right now it’s definitely not a big priority for me, but I want to match what the other older OCaml modes offered in that regard.

LSP Support

neocaml works great with Eglot and ocamllsp, automatically setting the appropriate language IDs for both .ml and .mli files. Pair neocaml with ocaml-eglot and you get a pretty solid OCaml development experience.

The creation of LSP really simplified the lives of a major mode authors like me, as now many of the features that were historically major mode specific are provided by LSP clients out-of-the-box.

That’s also another reason why you probably want to leaner major mode like neocaml-mode.

Other Goodies

But, wait, there’s more!

• C-c C-a to quickly switch between .ml and .mli files
• Prettify-symbols support for common OCaml operators
• Automatic installation of the required TreeSitter grammars via M-x neocaml-install-grammars
• Compatibility with Merlin for those who prefer it over LSP

The Road Ahead

There’s still plenty of work to do:

• Support for additional OCaml file types (e.g. .mld)
• Improvements to structured navigation using newer Emacs TreeSitter APIs
• More testing and addressing feedback from real-world OCaml users
• Actually writing some fun OCaml code with neocaml

If you’re following me, you probably know that I’m passionate about both Emacs and OCaml. I hope that neocaml will be my way to contribute to the awesome OCaml community.

I’m not sure how quickly things will move, but I’m committed to making neocaml the best OCaml editing experience on Emacs. Time will tell how far I’ll get!

Give it a Try!

If you’re an OCaml programmer using Emacs, I’d love for you to take neocaml for a spin. Install it from MELPA, kick the tires, and let me know what you think. Bug reports, feature requests, and pull requests are all most welcome on GitHub.

That’s all from me, folks! Keep hacking!

My institution-calendar package for Emacs displays term+week indicators in the *Calendar* buffer (which, by default, is produced by the calendar command). This is useful, for example, for schools who organise their work by terms, such as winter, spring, and summer, with each having a set number of weeks. This is how the University of Oxford will look like:

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.

Aimé Bertrand has an nice post on how he exports scheduled items in his org agenda to his macOS calendar. He mostly lives in Emacs and Org mode but, like, me also likes to have his appointments and other scheduled events in his macOS calendar. The main attraction for doing this to me is that it will sync all your appointments to all your devices as well as share it with appropriate other people. Sadly, Emacs doesn’t run on iOS and given Apple’s no interpreters policy, probably never will.

Bertrand wasn’t concerned with keeping the two calendars synced; he only wanted to export his Org scheduled events to the macOS calendar. This turned out to be harder than you might think. The existing solutions didn’t quite do what he needed so he decided to roll his own.

You can read his post for the details. He has a couple of different ways of approaching the problem. The details aside, the takeaway for me is the flexibility of Emacs and its ability to interact with other applications that may never have heard of Emacs.

If you’re using Emacs on a Mac and would like to ensure that all your Org scheduled events are reflected on the system calendar, take a look at Bertrand’s post for one way of solving the problem.

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

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.

Theena Kumaragurunathan, a filmmaker, photographer, and writer, has an interesting post on using Emacs for writing science fiction. There’s nothing new about that, if course. Several well known SF authors use Emacs. Kumaragurunathan’s post is interesting for two reasons:

1. The story of his journey from using a word processor, to a customized Vim/NeoVim editing environment, and finally to a happy Emacs user.
2. His use of Emacs as a model for his “Brain Computer Interface”, a central part of his story.

The brain computer interface (BCI) is how the technical elite communicate with a sentient AI 500 years in the future. The BCI is more complicated and featureful than that described in Niven and Pournelle’s Oath of Fealty. Instead of dealing with buffers, it deals with thought patterns and, as with Emacs buffers, they can be manipulated in various ways by a programming language built into the BCI.

It’s an interesting concept but for those of us in 2026, the real value of Kumaragurunathan’s post is his journey from word processors to Emacs. The journey is one of a quest to control his writing environment. Many Irreal readers will relate even if they have to substitute “programming environment” for “writing environment”.

Kumaragurunathan is promising a followup post in which he will discuss his Emacs workflow and how he uses it for writing fiction, research notes, film scripts, and even for programming. I’m looking forward to it.

Lin is a stylistic enhancement for Emacs’ built-in hl-line-mode. It remaps the hl-line face (or equivalent) buffer-locally to a style that is optimal for major modes where line selection is the primary mode of interaction.

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.

If you’ve ever enabled a new theme and noticed your tab-bar faces stubbornly hanging onto old colours or custom tweaks, I have found often that the tab-bar, tab-bar-tab, and tab-bar-tab-inactive faces don’t always blend cleanly with freshly loaded themes — especially of the older variety (a bit like me) and especially ones that came out before the tab bar was introduced into Emacs.

So how about a simple solution?, Can I implement something, that whenever I load a theme, the tab-bar faces update based on the theme’s default faces to establish a visually pleasant and coherent look?

Yes, yes I can!; the result is a tiny Elisp enhancement that hooks directly into Emacs’ theme-loading process.

Firstly however we need to have a method that will reliably pass over the themes default faces to the tab-bar. Here’s the function that realigns the tab-bar styling with your active theme:

(defun selected-window-accent-sync-tab-bar-to-theme ()
"Synchronize tab-bar faces with the current theme."
(interactive)
(let ((default-bg (face-background 'default))
(default-fg (face-foreground 'default))
(inactive-fg (face-foreground 'mode-line-inactive)))
(custom-set-faces
`(tab-bar ((t (:inherit default :background ,default-bg :foreground ,default-fg))))
`(tab-bar-tab ((t (:inherit default :background ,default-fg :foreground ,default-bg))))
`(tab-bar-tab-inactive ((t (:inherit default :background ,default-bg :foreground ,inactive-fg)))))))

This simply rebuilds the key tab-bar faces so they derive their colours from the current theme’s normal face definitions, so any old themes should now not leave the tab bar faces hanging.

Now for the function activation; Emacs 29 introduced enable-theme-functions, a hook that runs every time a theme is enabled — perfect for our use case, but as always I have my eye on older Emacs versions, so lets fall back to a classic approach: advice on load-theme.

Here’s a version‑aware setup that does the right thing automatically:

(if (version<= "29.1" emacs-version)
;; Emacs 29.1+ — use the official theme hook
(add-hook 'enable-theme-functions
(lambda (_theme)
(selected-window-accent-sync-tab-bar-to-theme)))
;; Older Emacs — fall back to advising load-theme
(progn
(defun selected-window-accent-sync-tab-bar-to-theme--after (&rest _)
(selected-window-accent-sync-tab-bar-to-theme))
(advice-add 'load-theme :after
#'selected-window-accent-sync-tab-bar-to-theme--after)))

With this tweak in place, every time you change themes, your tab-bar instantly updates, colours stay consistent, clean, and theme‑accurate without you having to do anything at all! The downside to this of course is that any newer themes that were created after the advent of the tab bar in Emacs will have their tab-bar faces overridden, but for me this solution is good enough and gives a pleasant coherent visual tab bar experience.

Yay!, yet another Yak shaved!

Álvaro Ramírez has a new Emacs app available. The app, winpulse, is his answer to keeping track of the active window. What happens is that every time the focus changes the new window flashes so you get a visual indication of the new window.

I had the same problem but solved it in a different way. I made the modeline of the active window a strikingly different color so that it’s easy to spot the one with focus. I like my solution better because the indication has longevity. If I get up and then return to my computer, I can immediately see which window is active. The nice thing about my solution is that it simply amounts to a set-face-attribute as you can see in my post or below.

None of this will come as news to Ramírez, of course. He simply prefers a different way of indicating the active window and, as always, Emacs makes it easy to have it your way.

Ramírez says the the app is brand new so it won’t be on Melpa yet but you can get it from its GitHup repository. If you like just having a momentary indication of the active window, Ramírez’s solution may be just what you’re looking for. If you prefer something a little stickier, changing the color of the modeline has worked very well for me. You could, I suppose even use both methods.

For the record, here’s the current code from my inet.el:

(set-face-attribute 'mode-line-active nil
:foreground "black" :background "goldenrod" :box '(:line-width 1 :color
"black"))

Unless you have a tan background, goldenrod probably isn’t the right color for you but you can experiment to see what works well with your theme.

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!).

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

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

1
2
3
4
5
6

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

A couple of observations:

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

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

It’s been years since I wrote about Gilles Castel and his astounding ability to take LaTeX notes so fast that he was able to keep up with the the instructor in his Mathematics classes. Sadly, Castel died in 2022 but his blog—including the two posts [1, 2] that deal with taking Mathematics notes with the associated diagrams—is still up.

Castel used Vim so he didn’t have AUCTeX but he did have a large collection of UltiSnips snippets that he used to make entering LaTeX fast and relatively painless. One feature of UltiSnips that he leveraged was the ability to specify the trigger word with a regular expression. For example, he uses that capability to recognize subscripts so that a2 → a_2. See his post for other examples.

Naturally, we Emacs nerds went crazy and attempted to replicate his system in Emacs. Karthink had a particularly good solution using AUCTeX, CDLaTeX, and YASnippet. Still it would be nice to be able to specify triggers with a regex.

Over at the Emacs subreddit, nmorazotti has a solution. He’s put together a snippet package, Resnippets.el, that can recognize a regex as a trigger. If you’ve been yearning to try Castel’s approach to taking LaTeX notes, resnippets may be useful.

I won’t be using it for two reasons. First it’s LLM generated and I have a prejudice—rational or not—against AI generated code. Second, and probably more important, is that the snippets are all autoapplied. I HATE that. I want to explicitly invoke the snippet with a Tab. Actually, UltiSnips has this right. By default you invoke its snippet explicitly but you can, on an individual snippet basis, choose to have them invoked automatically.

I don’t know if anyone is still interested in all this but it was fun for me to revisit it.

• Upcoming events (iCal file, Org):
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Feb 11 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Thu Feb 12 0000 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Feb 13 1800 Europe/Paris
  • EmacsSF (in person): coffee.el in SF https://www.meetup.com/emacs-sf/events/313232290/ Sat Feb 14 1100 America/Los_Angeles
  • M-x Research: TBA https://m-x-research.github.io/ Wed Feb 18 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Thu Feb 19 0000 Asia/Singapore
• Emacs configuration:
  • Philip Kaludercic: A retrospective on “setup”
  • Moving to vanilla Emacs - smallwat3r
  • verdant/emacs.d: My Emacs configuration. - Codeberg.org (@Verdant@c7.io)
  • Lightning Talk: Skewed Emacs (04:47)
  • Declarative, reproducible Emacs – video/blog (08:24, Reddit, Irreal)
• Emacs Lisp:
  • Toggle between let and let* (Irreal)
  • meedstrom/system-idle (Reddit) get the number of seconds since last user activity on the computer
  • vui.el: Building a File Browser - Boris Buliga
  • Lightning Talk: Emacs Lisp Rabbit Holes (04:03)
  • Lightning Talk: Common Lisp packages in Emacs Lisp (04:23)
• Appearance:
  • Yet Another Emacs Theme Gallery (Reddit)
  • Prikaz98/jblow-nostalgia: Emacs themes is stolen from John Blow Emacs streams (Reddit)
  • Protesilaos Stavrou: Emacs: new Doric themes ‘doric-jade’ and ‘doric-copper’
    • doric-themes version 1.0.0
• Navigation:
  • Charles Choi: Using Casual to work with Emacs Registers, Rectangles, and Windows (Irreal)
  • outline-indent.el - A modern indentation-based folding mode for Emacs (Release: 1.1.7) (Reddit)
  • spatial-window (Reddit)
  • Protesilaos Stavrou: Emacs: beframe version 1.5.0
• TRAMP:
  • ArthurHeymans/emacs-tramp-rpc: High-performance TRAMP backend using JSON-RPC instead of shell parsing (lobste.rs, lemmy.ml)
• Dired:
  • Symlinks and Hardlinks in Linux and Emacs (03:37)
• Writing:
  • Insert Special Characters into Emacs (02:21)
  • ctanas/tiles: Tagged Instant Lightweight Emacs Snippets (TILES) (Reddit)
  • In the Age of AI Writing Tools, I Picked Emacs for My Sci-Fi Novel (lemmy.ml)
• Denote:
  • TAONAW: Denote includes the option of adding different directories
• Org Mode:
  • Org Mode requests: [RFC] Rename :colnames header argument to :strip-colnames
  • Executive Function as Code: using (Doom) Emacs to script my brain (Reddit)
  • How I kickstart a new sprint in emacs (using org capture template) - short video in Reddit post
  • tzc/tzc-org.el at main · md-arif-shaikh/tzc · GitHub (Reddit)
  • (Experimental) Added custom view functionality to org-supertag
  • Jack Baty: Global org-capture shortcut in KDE (Irreal)
  • yingyu5658/niwa: My digital garden. (@Verdant@c7.io)
  • Aimé Bertrand: org-to-cal - Syncing Org Mode to macOS Calendar
  • [BLOG] #26 bbb:OrgMeetup on Wed, January 14, 19:00 UTC+3 - Ihor Radchenko (@yantar92@fosstodon.org)
  • Org development:
    • ox-latex: New keyword LATEX_CLASS_PRE to prepend lines before LaTeX preamble
    • org-update-statistics-cookies: Respect narrowing
• Completion: (the topic for this month's Emacs Carnival!)
  • Emacs Carnival: Completion — Where Are The Wise Men? (@mikehoss@appdot.net)
  • File name completion in Emacs - Dmitry Dolzhenko (@dsdolzhenko@fosstodon.org)
  • Completion (in Emacs hledger) — Arjen Wiersma
  • morazotti/resnippets.el: Regexp-based snippets for emacs (Reddit)
• Coding:
  • Release CIDER 1.21 ("Gràcia") · clojure-emacs/cider · GitHub - use buttons, drop support for Emacs 27
  • Thanos Apollo: (Video) Contributing to Git Projects with Magit: PRs, Patches & Agit workflow (YouTube 8:01)
  • Use prettierd as a formatter in apheleia
• Web:
  • ArthurHeymans/hugo-emacs-theme: A hugo theme that makes a blog look and operate like emacs (Reddit)
• Mail, news, and chat:
  • The Emacs RSS Reader I Wanted (Github, Reddit, YouTube 04:57)
• Doom Emacs:
  • PIMacs: A Modular, Documented, and Reproducible Doom Emacs Layer | PIPRIME.FR BLOG (@_PI_@fosstodon.org)
• Fun:
  • A SimCity clone in Emacs Lisp (Reddit, HN)
  • New version of the setup script for getting Emacspeak and Elmud working on Termux (@pixelate@tweesecake.social)
• AI:
  • ElleNajt/agent-shell-to-go (Reddit)
  • majorgreys/org-roam-skill (Reddit)
  • James Dyer: Spent a bit of free time polishing ollama-buddy - github Copilot is now onboard! ( Reddit)
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-01-27 / week 04
  • Emacs ATX Feb 2026 meetup notes
  • Protesilaos Stavrou: Prot Asks: Eric about free software, art, religion, and cosmic consistency
• Other:
  • Two Neat Emacs Packages: Bufferfile and Stripspace #rename #whitespace (02:54)
  • Plain text agenda (Reddit)
  • era-emacs-tools/ERA: Emacs Remote Editing (Reddit)
  • Comprehending MELPA's size
  • Resilient Technologies. Why Decades-Old Tools Define the ROOT of Modern Research Data Management (@lukascbossert@mastodon.social)
• Emacs development:
  • emacs-devel:
    • Help wanted for the widget library
    • Re: Supporting stylistic sets - Eli Zaretskii - more notes on stylistic sets
    • Re: Is it possible to suppress 'after-string overlay property by placing other overlays? - Eli Zaretskii - considering before- and after-string
  • Do cache and timed invalidation in "VC-aware" project backend
  • Fix selected group sort with topics (bug#80341)
  • Add missing symbolic prefix keybinding
  • Change the type of 'python-eldoc-function-timeout' to number
  • Support D-Bus file descriptor manipulation
  • Separate input histories for 'C-x v !' and Git pulling & pushing
  • Allow using xref-find-references without visiting a tags table
  • New minibuffer history for vc-user-edit-command (bug#80169)
  • Fix [More] buttons in tutorial and other buttons in Semantic
• New packages:
  • auto-space-mode: Auto add space between CJK and ASCII (MELPA)
  • consult-spotlight: Consult interface to macOS mdfind (Spotlight) (MELPA)
  • ddgr: DuckDuckGo search (MELPA)
  • dialog-mode: Major mode for editing Dialog files (MELPA)
  • doing: Frictionless activity log and time tracking (MELPA)
  • duckdb-query: DuckDB query results as native Elisp data structures (MELPA)
  • edna-theme: A dark, Edna-inspired theme (MELPA)
  • eldc: Emacs Lisp Dictionary Converter (MELPA)
  • elsqlite: SQLite browser (MELPA)
  • hanfix-mode: Korean grammar checker (MELPA)
  • lazy: Lazy evaluation library (MELPA)
  • magit-gh: GitHub CLI integration for Magit (MELPA)
  • magit-pre-commit: Magit integration for pre-commit (MELPA)
  • org-window-habit: Time window based habits (MELPA)
  • project-rails: Rails support for project.el (MELPA)
  • system-idle: Poll the system-wide idle time (MELPA)
  • warm-mode: Warm colors for nighttime coding (MELPA)

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

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

Hard to say officially, but I've been primarily using Emacs for roughly a couple of decades. Maybe my eyesight isn't what it used to be, or maybe I've just been wanting a stronger visual signal as I navigate through Emacs windows. Either way, today's the day I finally did something about it…

I asked around to see if a package already existed for this purpose. Folks shared a handful of great options:

• pulsar: Emacs package to pulse the current line after running select functions.
• dimmer.el: Interactively highlight the active buffer by dimming the others.
• window-dim.el: A window dimmer package for Emacs.

I wanted my windows to temporarily flash when switching between them. Of these options, pulsar came closest, though highlighting the current line only.

This is Emacs, so I should be able to get the behavior I want by throwing some elisp at the problem. With that, I give you winpulse, a package to temporarily highlight focused Emacs windows.

This package is fresh out of the oven and likely has some edge cases I haven't yet considered. If you're still keen to check it out, it's available on GitHub.

Make it sustainable

Enjoying this package or my content? I'm an indie dev. Consider sponsoring to help make it sustainable.

As you probably know, I’m a big fan of Charles Choi’s Casual Suite. His latest offering deals with registers, rectangles, and windows. Much as I like the Casual Suite, I won’t be using these latest menus. Choi, as usual, is absolutely correct about the various bindings being difficult to remember but I can remember that Ctrl+x r is the prefix for both registers and rectangles. If I type Ctrl+x r and wait a second, which-key will pop up a display with all the completions. This seems easier to me than invoking a Casual menu.

As for windows, I hardly ever want to rearrange them. Mostly I just want to switch focus between them and for that the excellent ace-window does the job nicely and I have it bound to Ctrl+x o one of the first bindings you learn as Emacs beginner. The only rearrangement I ever want to do is to switch two windows and ace-window does that if called with the universal argument.

Of course, all that’s just me. You may not use which-key and may often move your windows around. If so, Choi’s solution may be just what you need. He even has bindings for using the numeric keypad keys if you have a full size keyboard. If you already have Casual installed, all this is already available and all you have to do is specify some bindings for it as shown in Choi’s post.

At the beginning of the year, I jokingly resolved that I wouldn’t change my blog platform more than once every three months. Technically, I’ve kept my word. But last week Kev Quirk introduced his new blogging platform, Pure Blog. I am constitutionally unable to resist trying new blogging platforms, so I set up a copy and started tinkering.

It’s nice! It’s not technically an SSG (it uses PHP), but it maintains content as YAML-fronted Markdown files, just like most SSGs. What attracted me most, originally, was that the whole thing felt like something I’d build, given the time and talent. It focused on the things I find important, so it was a good fit right off the bat.

Here’s mine, so far, running at pure.baty.net. I’m playing with fonts and colors a bit. Currently, it mimics my Emacs theme, ef-day.

Without too much fuss, Pure Blog behaves the way I want a blog to behave. It’s simple, yet complete for what I need. I do have a wishlist, though.

• Footnote support
• Header improvements (such as making the blog title clickable or otherwise customizable)
• I’d like to override the Copyright text.
• A built-in /archive page with compact list of all posts, different from that of the home page. (I’ve made my own basic version)
• Possibly an easier upgrade mechanism. I’m using a custom justfile but it’s fragile. Kev’s instruction for upgrades are close, but miss things like /content/layouts/, which are technically code, not content. And custom CSS is edited using the admin panel, which makes that also content, not code. It’s not onerous now, but I have to pay more attention than I’d like.

In fairness, the whole project was meant to scratch a particular itch for one person. I’m not complaining! Like I told Kev, “Can open, worms everywhere!” :)

But now what? Part of me wants to break my rule and move baty.net to Pure Blog. That would be an enormous project, because years of using different tools has brought a variety of front matter formats (TOML, YAML, dates, tags, etc).

Another option is to make a new blog, such as I have so far with pure.baty.net, but even though the domain is fitting and kind of funny, I think the novelty will wear off.

I’m thinking about replacing baty.blog with a fresh new Pure Blog and leaving the old site behind. I have the content saved, so while it’ll break links, at least the content is still out there somewhere.

Anyway, Kev’s made a nifty, simple, useful, and easy-to-host blogging tool with Pure Blog. I need to figure out what to do with it.

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

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

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

Below are the release notes.

Version 1.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.

Why?

I am greatly fond of Org Mode. Everything happens in Org: tasks, notes, scheduling, you name it.

But here is the thing. I still want my events to show up in macOS Calendar. Why? Well, Calendar.app has nice widgets. It syncs to my iPhone. It sends me notifications that actually work. And sometimes, I just want to glance at my day without firing up Emacs. Also: Why not?

So the question becomes:

how do I get my Org scheduled items into Calendar.app without copy-pasting like some kind of animal?

What about existing solutions?

org-caldav is the full-featured option – bidirectional sync via CalDAV. But iCloud authentication is painful, and it kept breaking on me. Life is too short.

org-mac-iCal syncs the wrong direction (Calendar → Org) and hasn’t been maintained since OS X 10.5.

Org’s built-in ox-icalendar just exports. You still need to automate it and get the file into Calendar somehow. That’s the gap I wanted to fill.

The Solution

With a lot of coding assistant, a lot of (reverse) engineering and a lot of code review so that I do not break my stuff…

Enter org-to-cal – an Emacs package I wrote to solve exactly this. It exports Org items tagged with :ical: to macOS Calendar. Automatically. On save.

The package lives here: https://gitlab.com/aimebertrand/org-to-cal

How It Works

The concept is simple:

1. Tag your Org entries with :ical:
2. Save the file
3. The event appears in Calendar.app

Behind the scenes, it uses Org’s built-in ox-icalendar to generate a standard .ics file. Getting that file into Calendar is where it gets interesting.

Two Sync Methods

I implemented two different approaches. Pick your poison.

Server Method

A small HTTP server (Python, embedded in the package) serves the .ics file on localhost:8042. You subscribe to it in Calendar.app like any calendar subscription.

A LaunchAgent starts the server on reboot of the mac.

Direct Import Method

A Swift executable talks directly to EventKit (macOS’s calendar API). A LaunchAgent watches the .ics file and imports changes immediately.

Pros: Instant updates. No polling. Cons: Slightly more complex. Does not delete events (only creates/updates).

Or both

You can run both simultaneously if you want redundancy. I do.

How it works

Well i do not wanna bore you with all the details. The README.org is quite good and extensive.

Bonus: Cross-Machine Support

The direct import method has a neat trick. It stores event UIDs in a uid_map.plist file and embeds them in the event notes as [org-uid:xxx]. This means if you sync via iCloud and the local UID mapping is lost, it can recover by searching the notes field.

Granted, this is an edge case. But when it works, it feels like magic.

Caveats

Be advised:

This is one-way sync. Org → Calendar. If you edit events in Calendar.app, those changes will not come back to Org.

Also, the direct import method cannot delete events. If you remove the :ical: tag from an Org entry, the event stays in Calendar. You will have to delete it manually. ¯\_(ツ)_/¯

Conclusion

org-to-cal scratches a very specific itch of mine. I wanted my Org schedule in Calendar.app without thinking about it. Now it just happens.

The code is MIT licensed. Contributions welcome.

Resources

• org-to-cal on GitLab
• Org Mode iCalendar Export
• EventKit Documentation

If you aren’t an Elisp programmer—or at least some sort of Lisp programmer—this post won’t make much sense to you. If you do write in Elisp/Lisp, it tells you how to sand down a tiny bump in your workflow. It falls under the category of a small itch that you ignore until you can’t stand it anymore.

Over at the Emacs reddit, sauntcartas recounts how he always ended up needing to switch between let and let*. The difference is subtle—it concerns whether or not any of the arguments depend on any of the others—but the need to switch comes up naturally, often right in the middle of writing the code. It doesn’t take a lot of effort to navigate back to the let and add or delete the *, of course, but it does provide a bit of friction, especially if you write a lot of Lisp.

Emacs to the rescue. A tiny bit Elisp looks for the enclosing let and toggles it between the two forms. It’s a minor itch to be sure but it’s another great example of how Emacs can make your editing easier. If you write in Lisp, you really should add this bit of Elisp to your init.el. Sauntcartas’ code even reindents things if necessary.

After recently releasing magit-git-toolbelt, a Transient interface for git-toolbelt in magit, I’m happy to share another Magit extension I’ve been working on – magit-gh, an Emacs package that integrates the GitHub CLI (gh) into Magit. Similar to my former package, it provides a Transient menu interface to list, checkout, and view pull requests directly from Emacs without leaving your workflow.

Why I wrote this Link to heading

If you work with pull requests on GitHub every day, you know the git checkout dance: you’re deep in flow and in a Magit buffer, you need to check on a PR, so you switch to a browser, find the repo, navigate to the PR tab, and then maybe come back to checkout the branch in eshell or even your terminal. It’s a small context switch, but it adds up.

Forge has been the defacto and established solution for this and it’s a fantastic and comprehensive package for interacting with Git forges from within Magit – it has all the bells and whistles for this workflow. If you need deep integration – tracking issues, managing pull requests, reading and writing comments, all stored locally in a light database – Forge is the right tool. I would highly recommend Forge over this package if that is your use case.

magit-gh takes a different approach. It delegates to the GitHub CLI (gh) for all GitHub interaction, which means:

• No local database – Forge maintains a local SQLite database via emacsql, which can be tricky to set up (compiling native modules, resolving binary availability issues). magit-gh stores nothing locally.
• No token management – Forge requires a GitHub personal access token stored in your authinfo file (ideally encrypted with GPG). magit-gh piggybacks on gh auth login, which you have already configured from authenticating the first time.
• Minimal dependencies – just Magit, Transient, and the gh CLI.

The trade-off is that magit-gh is far less featureful than Forge. It is intentionally a lightweight alternative for users who primarily want to list, checkout, and view pull requests without additional setup overhead.

Installation Link to heading

You’ll need the GitHub CLI installed and authenticated first:

# macOS
brew install gh

# Linux (Fedora / RHEL / CentOS)
sudo dnf install gh

# Then authenticate
gh auth login

Then install magit-gh from MELPA:

M-x package-install RET magit-gh RET

Or with use-package:

(use-package magit-gh
  :ensure t
  :after magit)

Usage Link to heading

From any Magit status buffer, press , to bring up the magit-gh Transient menu. You can also invoke it directly with M-x magit-gh. The menu is organized into Pull Request commands:

magit-gh
└── Pull Requests
    ├── l  List open PRs
    ├── c  Checkout PR
    └── v  View PR in browser

When you list open PRs (l), a dedicated buffer opens showing PR number, title, author, and branch name. From that buffer you can checkout a PR with RET or c, open it in your browser with v, refresh the list with g, or close the buffer with q.

If you don’t like the , key binding, you can set a custom one. Note that the variable must be set before the package loads so it needs to be in the init section:

(use-package magit-gh
  :ensure t
  :after magit
  :init
  (setq magit-gh-key ";")) ; Example setting key to ";" instead of the default ","

To increase the number of PRs fetched (default 30):

(use-package magit-gh
  :ensure t
  :after magit
  :custom
  (magit-gh-pr-limit 50))

What’s next Link to heading

Aside from bugs and visual improvements to the TUI, I would consider this package mostly feature complete. The current feature set is intentionally small, but I have plans to add support for listing closed/merged PRs, creating new PRs, viewing diffs and CI status, and eventually issue management – all through the gh CLI. You can track progress on the GitHub repo.

If you use Magit and the GitHub CLI, give magit-gh a try! It’s available on MELPA and the source is on GitHub. Contributions and feedback are always welcome! Hope this is useful!

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

In this near-3-hour video I talk to Eric Frederickson about a broad range of issues that can be summed up under the theme of “cosmic consistency”. We start with a discussion about Eric’s endeavours with software development. I ask about Eric’s experience with free software and open source contributions, which makes us consider not just the programming side of things but also how there is a community-building component to the whole process. The development of GNU Emacs is a case in point. We explore how participating in free software is part coding part character building due to the social skills/interactions involved.

Our next big topic is art and creativity. Eric is a musician and has a keen interest in the artistic experience. Over the course of our talk we comment on ways to be creative, the different forms of expression we find from conservation to exploration, and how harmony is experienced. Many finer points here involve the sense of awe, how aesthetics cannot be reduced to words, that text alone disturbs us because we do not connect to a person’s emotional state, and more. Eric asks me what I think about the rhythm of life, also with regard to my way of choosing to live in the mountains and how all that underpins my creativity.

We share how myths and catchy stimuli play a key role in religiosity, as well as how religion cannot be reduced to a system of propositions: it also has a social aspect to it and a function of social reproduction. Our attention is focused on how people understand when not to take themselves too seriously. Examples we expound on involve Santa Claus and the Greek gods. In this regard I explain how Greek religion and Greek mythology are distinct, even if the latter draws inspiration from the former.

At many points we draw parallels between matters of human creation, such as art, and the natural order. For example, there is a way in which an idea stands the test of time when its application leads to viable results.

Eric has appeared before in this series: https://protesilaos.com/codelog/2025-07-23-prot-asks-eric-emacs-lisp-music-aesthetics-minnesota/.

Links from Eric

• My program “hms”, a featureful CLI time-duration calculator: https://emfred.com/programs/hms.

• My piece of music “Flying Home”, which features recordings of birdcalls at various playback rates: https://emfred.com/audio/sbp4-05-Flying-Home.mp3.

• My collection of music which includes “Flying Home”, called “Sketchbook, page 4”: https://emfred.com/sketchbook/pg4.

• And finally, in case a listener would like to contact me: https://emfred.com/about/contact

About “Prot Asks”

In this video series, I talk to anybody who is interested to have a video call with me (so do contact me if you want!). The topics cover anything related to Emacs, technology, and life in general. More here: https://protesilaos.com/prot-asks.

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

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

1
2
3

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

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

Each of these menus are detailed further below.

Rectangle Menu (casual-editkit-rectangle-tmenu)

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

Registers Menu (casual-editkit-registers-tmenu)

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

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

Windows Menu (casual-editkit-windows-tmenu)

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

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

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

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

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

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

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

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

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

Closing Thoughts

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

It is about five years ago that I submitted a package called setup to GNU ELPA¹. The premise was simple, I had grown dissatisfied with use-package and wanted to implement my own “configuration macro” that would be a better fit for packages written in a good style.

In this post I’d like to look back on the package and the macro, to chronicle my experience and the lessons I took away.

Issues with use-package

Among people who like Emacs, especially those who avoid learning to use Emacs by configuring it, it is popular to recommend use-package when configuring Emacs. The idea is that you can avoid a lot of repetitive idiosyncrasies by instead having a macro translate a declarative-esque DSL into the right code. It also allows the user to request that a package be installed at startup if it hasn’t yet been installed.

It was written by the renowned John Wiegley around the early 2010’s — which is important because the context of the time is an important influence on the features it implements: Keywords like :autoload, :mode :interpreter or :magic are not necessary if working with Emacs packages that have properly configured autoloads and use these to adjust variables like auto-mode-alist. I also assume that the default behaviour, not to install packages, goes back to this.

Totalling at around 3500 lines of Elisp it is also not trivial to keep an overview of the code, and in my opinion it is also more tricky to extend with new keywords — at least compared to the ease at which you can define a new command.

Finally, something I never managed to figure out how to reasonably have a consistent configuration that would also use use-package for built-in, non-packages. You can add these kinds of configurations to the pseudo-package emacs, but that felt like a kludge to me.

Idea of setup

Superficially the syntax of setup is different but not a radical departure from the use-package approach. Instead of using keywords like

(use-package flymake
  :bind ("M-n" . flymake-goto-next-error))

you would use a “local” macro, bound at compile-time around the setup form

(setup flymake
  (:bind "M-n" flymake-goto-next-error))

Note that the fact that the function symbol is a keyword is in no way significant. We could have also used &bind.

There were a few ideas and goals underlying the design:

• It should be easy to add a new local macro or change the behaviour of an existing one. I created a EmacsWiki page for people to collect ideas. For the sake of convenience, a function setup-define helps set up a local macro and provides a few shorthands to enable implicit looping and coercion. As a side-effect, you also get Xref integration on local macros!

• The setup macro is not declarative! Therefore it is nice if you can macro-expand the form and see what is going on. Take the two examples from above²:

  ;; `use-package'
  (progn
    (defvar use-package--warning2
      (function
       (lambda (keyword err)
         (let
             ((msg
               (format "%s/%s: %s" 'flymake keyword
                       (error-message-string err))))
           (display-warning 'use-package msg :error)))))
    (condition-case-unless-debug err
        (progn
          (unless (fboundp 'flymake-goto-next-error)
            (autoload (function flymake-goto-next-error) "flymake"
              nil t))
          (bind-keys :package flymake ("M-n" . flymake-goto-next-error)))
      (error (funcall use-package--warning2 :catch err))))
  
  ;; `setup'
  (eval-after-load 'flymake
    (function
     (lambda nil
       (define-key flymake-mode-map [134217838]
                   (function flymake-goto-next-error)))))

• The local macros use a separate, lexical scope to determine exactly what to expand to. Conventionally, the local context consists of the feature being configured (useful when wanting to generate code that should only be evaluated after the respective feature has been loaded), the current keymap, mode-hook, etc.

Here are a few examples from my init.el that I consider to demonstrate that applying these principles results in easy to read and write code:

(setup (:package writegood-mode)
  (:hook-into text-mode))

(setup (:package do-at-point)
  (:bind-to "C-'"))
  
;; slightly simplified
(setup (:and (executable-find "go")
             (:if-package go-mode))
  (setopt gofmt-command "goimports"
          gofmt-show-errors nil)
  (:local-hook before-save-hook gofmt)
  (:local-set compile-command "go build && go tool vet"
              tab-width 4)
  (:hook subword-mode))

For further details on the macro, I would recommend going to the EmacsWiki page linked above. The technical details are not of primary interest in this post.

A History of setup

Here I’d like to list a few events and comments in roughly chronological order:

• Upon submitting the package to GNU ELPA, it was Stefan Monnier who made a few important and very helpful comments that influenced critical features of the package. For this, and all advice since, I remain extremely grateful!

• The macro was featured in a stream later that year (2021) by David Wilson, on alternatives to use-package.

• Many people were upset over the name setup, and tried to get me to rename the package; I on the other hand loath (package) names that were obviously just chosen to be easy to look up on a search machine.

• The package was surprisingly popular on /g/. Some nice quotes:

  • “you should try setup.el sometime, its what use-package should’ve been”
  • “you should try setup.el next, the based non-bloated configuration package”
  • “Apparently, setup.el is better but use-package is built-in now”

• The last quote references to a major development in Emacs 29, that use-package, which had a tricky copyright situation until then, was added to Emacs OOTB. I actually ended up helping out with the process, though it was mainly driven by Payas Relekar and Stefan Kangas. By this move, setup lost an edge since before you first had to enable MELPA (later NonGNU ELPA, if it wasn’t already enabled) to install use-package, while now you can just use use-package directly.

• During the use-package merge discussion I had an exchange with John Wiegley where I demonstrated how an auxiliary macro could translate a use-package-like syntax into setup to simplify the processing. In the end the idea didn’t go anywhere.

• I had a number of nice conversations with people who liked the macro, and multiple contributions by Okamsn (maintainer of the loopy macro, which I don’t think is coincidental).

• There haven’t been many changes for the last two years. The last local macro I added was in 2024 (over two years ago at this point) and I have been deprecating more stuff since then (mostly macros like :option that are not context-specific and are better replaced using a more general macro like setopt), but haven’t removed it yet.

  This is both a sign of decline and stability. While fewer people are using it, the fact that no further changes have been necessary is a sign that it does what it should. There are a few things I might change if setup is ever bundled with Emacs, for instance I might want to deprecate :when-loaded (the analogue of :config in use-package) because I think that anything you’d write within this local macro should either be replaced by a specific local macro or is a bad upstream design of the package maintainer.

The future of setup

I have to admit I am not as enthusiastic about the macro as I was 2021. It is not that I dislike it, the implementation still seems good and I enjoy reading it, but I am mostly indifferent about the need for configuration macros in general.

Over the last two years I have configured Emacs from start on two work machines, and both times I was more than just fine to append stuff to my init.el and use Easy Customization Interface. At the same time I continue to use setup on my personal machine, and as I grow ever more convinced of the fact that (obsessive) configuring of Emacs is a sign of a fatal misunderstanding of Emacs on some level, I don’t have the motivation to rewrite it because I don’t really have anything to gain from it. Most of the times I touch my init.el is to bind a new command, set a new user option or in the best case delete some code if an analogous feature has been upstreamed.

I don’t really know who uses setup anymore, but I am aware of people who have used it in the past and given up. Interesting nobody points me to a specific reason or issue, but my impression is that most people run into a similar kind of lethargic apathy, but decide to jump to something else instead (again, since the upstreaming of use-package I myself have considered switching a few times to simplify my configuration, but never gone through with it).

Finally, I recently suggested replacing the idea of setup macros with a more non-Lisp’ish configuration syntax, and explained why in the aforelinked article. I haven’t continued developing the proposal, though I still think it is more user friendly to someone who prefers to think of configuring Emacs not as programming with a understanding of what is going on but as toggling the right knobs to get the intended behaviour.

So the future is certain and reliable that the macro will stick around, and I guess I’ll keep on maintaining it?

Jacob Boxerman has a nice video and related blog post about his approach to configuring Emacs in a declarative and reproducible way. By “reproducible” he means that if he installs his init.el on a new system, he gets the exact same Emacs environment. That doesn’t mean just things like colors and key bindings but also that the same versions of the same packages are loaded and available.

By “declarative” he means, essentially, that he uses use-package and straight.el to specify and configure his packages in a declarative way. The goal is that the order of the declarations doesn’t matter and if one declaration s deleted, no other package is affected.

The video is a tour through a sample configuration based on Boxerman’s that shows how he accomplishes these things. The declarative part is mostly handled by use-package while the reproducible part depends mostly on straight’s ability to lock a file to a specific version. Take a look at the video and associated blog post for the details.

If, like me, you don’t have multiple machines that you require to provide exactly the same Emacs environment, you can probably omit straight.el but the idea of putting all your configuration in use-package blocks is a good one. It goes a long way towards ensuring that changes in one area won’t affect things in another.

Boxerman describes an excellent way of keeping your Emacs configuration under control and avoiding problems when—inevitably—you have to make changes. The video is only 8 minutes, 23 seconds so it’s easy to find time for it. If you find his ideas useful, take a look at his post, which explores them in a bit more detail.

Just a quickie today. Jack Baty has a short post on how he enables Org capture from anywhere on his system. He does pretty much what I do except that I use yequake instead of his custom script.

Yequake probably handles the edge cases but either way you simply evoke Emacs and ask it to run a bit of custom Elisp. If you aren’t doing something like this, you should take a look at Baty’s post or Alphapappa’s yequake. No matter where you are, you can bring up your capture menu and bring notes or a browser link into Emacs. I use it many times a day, especially for capturing items that I might want to write about in Irreal.

This is just another example of how Emacs can ease your workflow. You simply pop up an Emacs frame, capture you note, and deal with it later. It’s about as easy a way of capturing a quick note without breaking you out of the flow as you can get. If Emacs is at the center of your workflow, you should definitely check out Baty’s post or Alphapappa’s yequake.

Contributing to Git Projects with Magit: PRs, Patches & Agit workflow

Quick video guide on contributing to git projects using Magit. Showing an overview of the 3 most commonly used workflows

• Pull Requests

• Agit Workflow

• Git patches

  Video notes:

Introduction

I’m creating this as a tutorial video on how to contribute to bebliotheca, a digital recreation of the Library of Constantinople to host texts that would have been found there during the Greco-Roman Empire.

The steps demonstrated here are applicable to any project.

This is a video guide on contributing to git projects, using Emacs and Magit (the magical Git client). Magit provides the best experience out of the box for a text based interface to git, which makes magit an emacs’ killer feature.

In this video we will start from an example Emacs configuration, adding a theme and installing Magit. Afterwards we will see how to contribute to git projects in 3 ways:

• Pull Requests
• Agit Workflow Pull Requests
  • Supported in forgejo instances, such as codeberg
• Git Patches

I personally use vc, a built-in module. But that’s because I enjoy tinkering and writing my own scripts for it. Magit does by default a lot more that even my ~300 line vc config can do.

Requirements

You will need the following software installed:

• git
• GNU Emacs (version >=29.2)

Additionally, ensure you have a pair of SSH keys already generated and set up for your forge.

Emacs Configuration I will be using

Example init.el file that I will be using:

• Defaults locations for init.el, depending on your system:
  • GNU/Linux: ~/.emacs.d/init.el
  • Windows: C:\Users\<YourUsername>\.emacs.d\init.el

;; Init packages
(package-initialize)

;;;; Do not install keycast as well, I'm only using it to share my
;;;; keystrokes for the video.
;; (use-package keycast
;;  :ensure t)



;; Set and load custom.el
(setf custom-file (locate-user-emacs-file "custom.el"))
(load custom-file 'noerror)

;; Completions
(fido-vertical-mode 1)
(electric-pair-mode 1)

;;; Theming ;;;

(column-number-mode)
(global-display-line-numbers-mode 1)
(tool-bar-mode -1)
(tooltip-mode -1)
(menu-bar-mode -1)
(blink-cursor-mode -1)
(scroll-bar-mode -1)
(set-fringe-mode -1)

;; Add transparency
(add-to-list 'default-frame-alist '(alpha-background . 85))

;; ef-themes package provides a great theme collection, made by Protesilaos.
(use-package ef-themes
  :ensure t)

(defun thanos/load-theme (&optional theme)
  "Disable current theme and load a new THEME.
Emacs can load multiple themes at once.  With this function we make sure we only load one at a time"
  (interactive)
  (let ((theme (or theme (intern (completing-read "Theme: " (custom-available-themes))))))
    (disable-theme (car custom-enabled-themes))
    (load-theme theme t)))

(thanos/load-theme 'ef-dark)


(use-package magit
  :bind ("C-x g" . magit)
  ;; Hook flyspell for autocorrect during commit messages.
  :hook (git-commit-mode . flyspell-mode))

;; Agitjo extends Magit with a new menu for AGit-Flow operations.
(use-package agitjo
  :vc (:url "https://codeberg.org/halvin/agitjo")
  :ensure t)

Pull Requests

• Require an account creation for the forge the project is hosted at. e.g Github or Codeberg.
• Steps to submit a PR
  • Fork repository, through a Web UI.
  • Clone your fork
  • Commit changes, often in a new branch.
  • Push your changes to your fork
  • Submit a Pull Request, through a Web UI.

If you’d rather not use a Web UI, but have to use Pull Requests, consider using forge.

Agit workflow

Note that the agit workflow is not supported by GitHub at the time of making this video. To use agit workflow, you will need to utilize a forgejo instance such as Codeberg.

• Clone repo, using ssh
• Commit changes
• Push
  • From the Magit status buffer, press #
  • Specify a title using -t
    • You can use the same title to push changes to the PR.

Git patches

• Clone repo.
• Commit changes.
• Format patches.

$ git format-patch -{NUM} # where NUM the number of commits.

• Send patches as attachments via email, by pressing C-x C-m.

Denote includes the option of adding different directories, so this now makes sense:

(setq denote-directory
      (if (eq system-type 'gnu/linux)          ; If I'm using Linux, include the private folder.
          (list (expand-file-name "~/Sync/Notes")
                (expand-file-name "~/Documents/private"))
        (list (expand-file-name "~/Sync/Notes")))) ; If I'm using anything else (macOS) just Notes.

(setq denote-excluded-directories-regexp "data") ; the data folder (with attachments) is excluded.

I have a private folder for Denote notes on Linux only. I used to only sync my Sync/Notes folder, which includes my informational notes and blog posts, but that means I’m missing out on Denote’s abilities in my private folder, which is slowly increasing in size. This solves this problem.

There’s no need to list the data folder (which includes my attachments, mostly in file formats that are not Denote’s format), so that’s why the exclusion is there.

I should be taking more photos. One roll of film for the entire month of January is embarrassing. I have a new Leica Q2 to play with, and I’ve taken maybe 20 images with it so far. What’s up with that?

I’m bored with all the performative quitting going on. What do you want, a medal?

Later: I don’t think Dave cared for my comment about being bored. Fair enough. Sorry, Dave, you’re excluded of course :). I wasn’t “sub-posting” you or anyone else in particular. And I’m not bored with people quitting things that don’t line up with their ethics or anything else. That’s excellent. I’m bored with people talking about it in that particularly smug tone that social media brings out in people. Frankly, I’m so angry about just about everything happening righ now I can hardly think. I’ll exercise my privilege by being bored by the tiresome discourse around so much of it.

Come to think of it, I’m bored by just about everything. I seem to have only two reactions to everything: anger or boredom.

Took the M3 loaded with a roll of HP5 over to my grandson’s this morning. Shot the roll at ISO1600. Nothing very good to show for it, but at least I did something.

I like being able to create new Org mode tasks from anywhere, via a simple keyboard shortcut. This probably doesn’t justify a whole post, but here’s how I did it.

Create a script at ~/.local/bin/orgcapture.sh

Here’s the script:

#!/bin/bash
emacsclient -c -F '((name . "capture") (width . 80) (height . 34))' -e '(progn (org-capture) (delete-other-windows))'

In my Emacs config, I have a hook that tidies up the new frame:

(defun my/org-capture-finalize-hook ()
  "Close frame after org-capture if it was opened for capture."
  (when (and (> (length (frame-list)) 1)  ; More than one frame
             (frame-parameter nil 'client)) ; Frame created by emacsclient
    (delete-frame)))

(add-hook 'org-capture-after-finalize-hook 'my/org-capture-finalize-hook)

In KDE’s Settings, I added a new command in the Shortcuts settings that point to that script. I assigned it to F3.

Now I hit F3 any time and a small capture buffer pops up in a new frame. That’s it. If there’s a better method for doing this, let me know.

I have added two new themes to my minimalist doric-themes package. The collection is growing to cover styles that range from austere to playful.

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.

I’ve had a little free time recently (figuring out this baby stuff!) and thought I would spend time revisiting and refining my AI assistant ollama-buddy

I’ve been playing around with agentic coding and keeping up-to-date on the rapid development of the Emacs AI package landscape and I think I have refined in my own mind my idea of what I would like to see in an Emacs AI assistant.

The headline change regarding the latest release of ollama-buddy is GitHub Copilot integration; the rest of the work is about smoothing the UI and simplifying day-to-day use.

What’s new - the Copilot addition (v1.2)

• GitHub Copilot Chat API support via a new file, ollama-buddy-copilot.el, so Copilot models can be used alongside your existing providers.
• Authentication uses GitHub’s device flow (OAuth). No API key required: M-x ollama-buddy-copilot-login opens a browser and guides you through secure authentication.
• Copilot models are identified with a “p:” prefix (for example, p:gpt-4o). The header line shows a “p” indicator when the Copilot provider is loaded so you always know it’s available.
• Copilot access exposes a broad set of models from multiple vendors through the Copilot interface: OpenAI (gpt-4o, gpt-5), Anthropic (claude-sonnet-4, claude-opus-4.5), Google (gemini-2.5-pro), and xAI models.
• Quick usage notes:
  1. Ensure you have an active GitHub Copilot subscription.
  2. Run M-x ollama-buddy-copilot-login.
  3. Enter the device code in your browser at github.com/login/device when prompted.
  4. Select a Copilot model with C-c m (e.g., p:gpt-4o).
• Example config to load Copilot support:

(use-package ollama-buddy
:bind
("C-c o" . ollama-buddy-menu)
("C-c O" . ollama-buddy-transient-menu-wrapper)
:config
(require 'ollama-buddy-copilot nil t))

Other notable updates in this release series

• v1.2.1 (2026-02-02)
  • Attachment count indicator on the header line so you get a constant visual reminder that the session has attachments.
• v1.1.5 (2026-01-31)
  • Global system prompt feature (enabled by default): sets a baseline set of instructions (for example, to prefer plain prose and avoid markdown tables) that is prepended to session-specific system prompts. This helps keep responses consistent across providers and things like malformed markdown tables for example, which seems to be common. There’s a toggle (ollama-buddy-global-system-prompt-enabled) and a quick command to flip it (ollama-buddy-toggle-global-system-prompt), plus a transient-menu entry.
  • Consolidated model management: streamlined into a single model management buffer (C-c W) and the welcome screen now points to that buffer for model tasks.
• v1.1.4 (2026-01-31)
  • Header-line and keybinding cleanup: C-c RET to send prompts (matches gptel, as I feel this seems intuitive), removed a redundant backend indicator, shortened the markdown indicator to “MD”, and fixed markdown → org heading conversion to keep structure sane.
• v1.1.3 (2026-01-31)
  • Chat UX improvements and simplification: added ollama-buddy-auto-scroll (default nil — don’t auto-scroll so you can read while streaming) and ollama-buddy-pulse-response (flashes the response on completion, taking from gptel again, as if there is no autoscrolling it is useful to visually see when the response has completed). Removed the model name coloring feature and related toggles to simplify code and improve org-mode performance.
• v1.1.2 (2026-01-30)
  • Streamlined welcome screen and model selection, clearer provider indicators in the header line and an improved list of enabled online LLM providers.

beframe enables a frame-oriented Emacs workflow where each frame has access only to the list of buffers visited therein. In the interest of brevity, we call buffers that belong to frames “beframed”.

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

A couple of weeks ago, I wrote about how Punchagan over at NOETIC NOUGHT started saving his Elfeed database after he lost it in a system crash. At the time, Punchagan didn’t know exactly what happened, only that the system crashed and he lost his Elfeed database. He wasn’t even sure that the two events were related, only that they occurred at the same time. His solution to the problem was to set up periodic saving of his Elfeed data to git.

A little later he had some time to troubleshoot the problem and discovered what happened. The Elfeed database is basically a hash table and saving it is simply a matter of dumping the binary to a file. This happens inside a with-temp-file macro, which is much like the more familiar with-temp-buffer macro except that it saves the results to a file at the end. The saving is done with write-region, which first truncates any existing file.

What happened, apparently, is that the system crashed between the truncation of the old file and writing the new file. Sadly there’s not much that can be done at the user level other than saving the file periodically.

I liked this post because it shows how easy it is to simply follow the code—which is, of course, available whenever you’re running Emacs—to see what’s happening. Emacs, to be sure, has more sophisticated tools for debugging but often simply looking at the code will reveal what’s going on. Punchagan’s post reminds me of Sacha Chua’s post on figuring out how to edit an SVG file and its source at the same time. She figured out how to do this the same way as Punchagan solved his problem: by reading the source code to see where the undesirable behavior was happening.

• Upcoming events (iCal file, Org):
  • Emacs: un editor del pasado para el futuro (in person) https://gpul.org/eventos/2026/emacs/ Thu Feb 5 1200 America/Toronto
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/312922157/ Thu Feb 5 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto – Fri Feb 6 0000 Etc/GMT - 0100 Europe/Berlin - 0530 Asia/Kolkata - 0800 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Feb 6 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Sat Feb 7 0000 Asia/Singapore
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Feb 11 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Thu Feb 12 0000 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Feb 13 1800 Europe/Paris
• Beginner:
  • Essential Tips and Tricks for Efficiency – Emacsfr (@unixbhaskar@mastodon.social)
• Emacs configuration:
  • Post your favorite DWIM commands, packages, or own hacks
  • Using Minimal Emacs with Nix (@totherme@tech.lgbt)
  • Kickstart.emacs: Got a huge update. (Reddit)
  • Startup Changes in Emacs 31.1 The "user-lisp" Directory
• Emacs Lisp:
  • Use Batch Mode to Test Your Dot Emacs File (02:36)
  • Listful Andrew: ISO week dates in Emacs Lisp and Bash
  • Trevoke/elk: project management tool for emacs lisp - Codeberg.org (Reddit)
  • duckdb-query.el - DuckDB SQL/Elisp: query parquet, CSV, org-tables, alists in the same SQL statement seamlessly (Reddit, Reddit)
  • [17] Emacs Reader: Cursors, PALE, Canvas API and More! - 2/2/2026, 2:33:39 PM - Dyne.org TV
  • [17] Emacs Reader: Cursors, PALE, Canvas API and More! - 2/2/2026, 2:26:28 PM - Dyne.org TV
  • #80281 - 31.0.50; FR: Canvas object as display property - GNU bug report logs (@tusharhero@mathstodon.xyz)
  • pale: Picture and animation library for Emacs (@divyaranjan@mathstodon.xyz)
• Appearance:
  • halych/sans-mono: Configure proportional fonts for editing text in emacs - Codeberg.org (@halych@mastodon.sdf.org)
  • Protesilaos Stavrou: Emacs: ef-themes version 2.1.0
• Navigation:
  • Irreal: When Should You Use Visual-line-mode?
  • Tip about using hs-minor-mode for code folding
  • Recursion and Quitting in Emacs (07:06)
• Writing:
  • Sacha Chua: Emacs and French: Focus flycheck-grammalecte on the narrowed part of the buffer
• Denote:
  • TAONAW - Emacs and Org Mode: Why I use Denote?
• Org Mode:
  • Stefan van der Walt: org-mode Day Planning with Time Blocks
  • Irreal: Starting A Journal
  • James Dyer: Auto-Populating Weekly Dates in Org-Mode Tables
  • 我是如何构建这个站点的
  • TAONAW - Emacs and Org Mode: Org files to beautiful docx files with Pandoc (Irreal)
    • dwim-shell-command-pandoc-org-to-docx
  • PSA searching org mode notes for tags even with org roam? use 'org-match-sparse-tree' instead of 'org-roam-node-find'
  • bradmont/org-roam-tree: organize backlinks in the org-roam buffer as a tree (Reddit)
  • Org development:
    • New option (org-latex-use-sans): Control using Sans as default font
    • Update all the links to savannah to use nongnu.org
    • ox-man: Add support for footer-inside and header-middle
    • org-lint: Add check for priorities
    • speed-commands: Adapt priority commands to user options
• Completion:
  • Snippy.el: VSCode/LSP snippet support for Emacs with Yasnippet. (Reddit)
  • James Cherti: ultisnips-mode.el (*.snippets files) (Github, Reddit) mode for editing Vim-compatible snippets (can be translated to Yasnippet for use with Emacs)
  • Sacha Chua: Emacs Carnival February 2026: Completion
• Coding:
  • Paxedit - a complement to Paredit (Reddit)
  • Heads-up for CIDER users: Elisp sources are now under lisp/ (@bbatsov@hachyderm.io)
  • Magnus: More on the switch to eglot
  • Marcin Borkowski: git-link
  • Mike Olson: First Week with Jujutsu VCS
• Math:
  • Lars Ingebrigtsen: Some Minor eplot Tweaks for CSV Files
  • Automatically Export Emacs SES Files to TSV - Lemmy.World
• Shells:
  • Charles Choi: Getting Eshell nth History to Work
• Web:
  • Converting Mozilla Firefox bookmarks to Org Mode (@totherme@tech.lgbt)
  • Linkding: Add URLs from Emacs, open bookmark in preferred browser (@mmk2410@fosstodon.org) integration with linkding self-hosted bookmarking service
  • Vibe Coding an Emacs-Style Hugo Theme | Arthur's blog (Github, HN)
• Mail, news, and chat:
  • punchagan: Why my Elfeed index was 0 bytes (Irreal)
• Multimedia:
  • Sacha Chua: Queuing multiple transcriptions with whisper.el speech recognition
  • Sacha Chua: Using Silero voice activity detection to automatically queue multiple transcriptions with natrys/whisper.el
  • Rendering 30FPS Video Inside Emacs Text Buffer (Reddit)
• Fun:
  • All codes lead to Home (Reddit)
  • minad/doom-on-emacs: DOOM on Emacs (Reddit, HN)
  • lichess.el: Watch Lichess games and play against Stockfish (HN)
  • Script for getting Emacs, Emacspeak, and Elmud running on Termux (@pixelate@tweesecake.social)
• AI:
  • Evan Moses: Yak Power-Shears: LLMs are pretty good at Emacs
  • Alternative transient documentation - also discussion about using AI to generate documentation
  • James Dyer: Ollama buddy now supports cloud models! (YouTube 01:04, Reddit)
  • ECA: AI pair programming in your editor - Dallo (32:33)
  • alvarmaciel/amp-emacs: Deep integration of Sourcegraph Amp with Emacs, inspired by amp.nvim. (Reddit)
  • I tested Claude Code today - And it built a proper agent package in emacs for me. (Reddit)
  • Stefan van der Walt: Using Gemini for Code Patches in Emacs
  • So, I "vibe-coded" features missing in Backpack Emacs, yet another GNU Emacs distribution (Reddit)
  • Short HN discussion about agent-shell
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-01-27 / week 04
  • TAONAW - Emacs and Org Mode: Reflection on my Emacs experience
  • Amy's story behind Org Real and the boxy layout system
  • Michal Sapka: RTE - Return to Emacs (Irreal)
  • Christian Tietze: Emacs Carnival 2026-01: “This Year, I’ll …”
    • Zimblo: Emacs Carnival Jan 26: “This Year, I’ll de-obfuscate” | zimblog
    • George Jones: This Year I'll… · Curious Musings
    • Arjen Wiersma: This year, I'll…..
    • Sacha Chua: Emacs: This year, I will… / Cette année, je vais…
    • John Rakestraw | Emacs Carnival: This year, I'll …
    • Neil Mather: Emacs Carnival: This year I'll…
    • Kana: This year, I will write a shitty GUI for my Emacs clone
    • Sebastian Larsen Prehn: This Year, I'll …
    • Christian Cleberg: Emacs Carnival: “This Year, I Will…”
    • Lio Novelli: This year I'll …
• Other:
  • Sorting Lines by Fields in Emacs (02:57)
  • Protesilaos Stavrou: Emacs: tmr version 1.3.0
  • Irreal: Gruber On File Saving Ease
  • Irreal: Emacs Performance on macOS
  • teamtype/teamtype at emacs-plugin (@teamtype@fosstodon.org)
• Emacs development:
  • emacs-devel:
    • Some notes on stylistic sets and how shaping works
    • Trying to split feature/igc into smaller pieces
  • display-time: Add option to customize help-echo format
  • Add new input method for Tuscarora
  • New function 'truncate-string-pixelwise' (bug#80244)
  • Make diff-hunk-kill respect an active region
  • Bind 's' to diff-split-hunk in read-only diff-mode
  • New function 'checkdoc-batch' (bug#80199)
  • New key 'M-j' for 'icomplete-mode' (bug#62108)
  • New C-x v T l and C-x v T L commands (vc-log-outgoing-base, vc-root-log-outgoing-base) show corresponding revision logs
  • (minibuffer-message): Do not block while displaying message.
  • Move outstanding changes commands from 'o' to 'T'
  • Add 'select-frame-by-id' and 'undelete-frame-by-id' (Bug#80192)
  • Support cons cell for 'line-spacing'
  • New bindings for vc-revert
  • Flymake support for yaml-ts-mode.
  • Add JSON path utility command to json-ts-mode
  • (garbage-collect-heapsize): New function
  • * lisp/tab-bar.el (tab-bar-split-tab): New command.
• New packages:
  • dialog-mode: Major mode for editing Dialog files (MELPA)
  • duckdb-query: DuckDB query results as native Elisp data structures (MELPA)
  • eldc: Emacs Lisp Dictionary Converter (MELPA)
  • lazy: Lazy evaluation library (MELPA)
  • magit-pre-commit: Magit integration for pre-commit (MELPA)
  • org-window-habit: Time window based habits (MELPA)

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

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

JR over at The Art Of Not Asking Why has a useful post on exporting an Org document to Docx. I’ve written about this before [1, 2, 3] and you might wonder why. After all, you can simply export directly from Org to ODT and get a Word compatible document.

The problem occurs when you’re working in an environment that requires a specific style implemented with a Word style sheet. The native Org exporter doesn’t support this so the usual solution is to use Pandoc, which does support a Word style sheet.

JTR’s post has a step-by-step recipe for making the conversion and setting up a Word style sheet using a reference document with the desired settings. He even covers the difficult areas of images and tables, which, of course, require further machinations.

None of this would be necessary if Word and its siblings would use plain text instead of an arcane, opaque file structure to store the document. After all, it’s certainly possible as Org—or, if you require even more complicated output, TeX/LaTeX—show. But, of course, that would stand in the way of editor lock in.

Regardless, if you have to produce Word documents but prefer to write in Org, take a look at JTR’s post. He shows you how to produce a good looking Word document from an easy to write Org file. He even shows how to automate the process using Álvaro Ramírez’s dwim-shell-command.

When it comes to sharing written documents with my co-workers, I usually need to use Word or PDFs. Org-mode includes an export option to odt files, which does the job in a pinch, but it’s a bit harder to customize, especially if I want to preserve certain formatting elements. In the past, I used to create ODT files, import them into Word, make whatever changes I needed, and save them in a docx file. The problem there, besides the manual work, is consistency. If I want to make sure I use the same style for fonts, header sizes, and table formats, things get annoying fast.

About a year ago, I discovered that Pandoc can use an external Word document (docx) as a style template. As long as I have this file accessible, every org file I convert to docx will automatically (and beautifully, I may add) retain the exact style changes I need. This, of course, can be automated later inside Emacs, so the export process is basically seamless.

The problem lies in the fact that you need to work with Word and understand how its styles. Readers of this blog know I love to complain about Microsoft’s UI and its lack of consistency, and the instructions here are one fine example in my opinion. Be it as it may, I will try to keep the snarky comments in check.

Creating the default style sheet

The first thing to do is get Pandoc to create its default style reference document as a .docx. This can be done with pandoc -o custom-reference.docx --print-default-data-file reference.docx.

What you’re telling Pandoc here is to output (-o) a file named custom-reference.docx (you can call it whatever you’d like, as long as it’s a docx, since you want to work with Word). What to output goes into this file? The default reference document.

Once you do that, you will have a custom-reference.docx in the folder you ran the command from.

Now it’s time to work inside Word.

Modifying the styles

What you will see is a rather plain file listing a bunch of styles and their name. First, you will see “Title,” and it will be nice and big because it’s using the Title style in Word. Heading 1 will use the Heading 1 style, Body Text (further down) will use the Body Text style, and so on.

What you want to do is to access these styles in Word. You will be modifying them to fit to your liking.

To do that, search for the Styles Pane. In my case, Office 365 for macOS, I can find it in the ribbon under Home, but I wouldn’t be surprised if that’s a little different if you’re using Windows, or a different version of Word.

With the Style Pane open, you will see a long list of the available styles. You can navigate this way, but I find it’s easier to just look for them in the document to the left and select them; it will then show under Current style: to the right.

Now that you have a style selected, select the name of that style from the Style Pane and choose Modify Style…¹. You will see the options available to you, such as the font name, text color, alignment, etc.

Make sure that you do not change the Name: of the style! You’re modifying existing default styles that Pandoc recognizes; if you create a new one (by giving it a new name), Pandoc will not know what to do with it and will ignore it. Remember, you are modifying a reference sheet of existing styles, not creating new styles. Likewise, this means that you have no reason to change anything in the document itself (the content) - Pandoc doesn’t care about that and will ignore it. You’re only touching the options in the Modify Style… window.

That’s basically all there is to it. As you will see soon, some items can get a bit more complicated as they are not available in the same way. Save the files when you’re done modifying the styles. You will probably keep going back to this document as you export docx files, tweaking things until you like them.

Using Pandoc to export from org-mode to a docx file

The next step is to tell Pandoc to convert an existing org file to a docx file using the reference sheet we just worked on. To do that, use the following command:

pandoc -s <input_file.org> -o <output_file.docx> --reference-doc custom-reference.docx.

The idea is the same as before, but we use a stationary option, -s (the reason for that is that we’re telling Pandoc to use a “full” version of a document, needed with the reference doc option, otherwise it can’t use our reference document).

Then, we’re pointing Pandoc to our org file and using the output, -o, as the doc file we want, then finally using the reference-doc option by utilizing our reference file, custom-reference.docx (unless you change the name to something else). That’s it, Pandoc will create the file in the folder you are in.

Images and Tables

For me, things get a bit more complicated. My technical documents often include screenshots, and I need those embedded in the resulting Word docx file.

The above command will embed images in the Word document, as long as org-mode can find and display your images (using the inlineimages option in org-mode). My org-mode technical notes are all written with Denote these days, which keeps everything organized, including the images, which are inside the default data subfolder. If your workflow is different, be mindful of your path to the images; you’d probably want to use an absolute path in org-mode (use C-u C-u C-c C-l when linking an image instead of the usual C-u C-c C-l for this). There’s also the option to extract media in Pandoc (see the –extract-media option). In my opinion, it’s simpler and cleaner to dedicate a folder for your org documents, completed with a subfolder for attachments.

Another issue that stumbled me was the tables.

Pandoc’s default style for tables is minimal - without borders. This might look nice if you want to hide your tables, but if you need a table with borders and perhaps some shading, you’ll run into issues.

The problem is with Word. The style for the table is not included in the Style Pane. In order to change the style for your table in the reference doc, you need to locate Table Design in your ribbon. Notice that if you work on a small screen (like in my recording), you might have to expand your options to find it. Then, you will have to extend the pane further and locate the Modify Table Style below. Once again, this is true for my case, Office 365 on macOS. If you’re using a different Office version or on Windows, this menu might be located elsewhere.

Once you have Modify Table Style open, you can change the borders and shading to your heart’s content, but as before, make sure the style name remains Table. If you create a new style, Pandoc will ignore it.

A few tricks I picked up

Under the name of the style, in the Modify Style or Modify Table Style window, you will see the Style based on option. You can change this option and browse through different colors and fonts to find something you like, and then customize further instead of starting from scratch. As long as you don’t change the name of the style, you’re OK. I found this useful when working with tables, as I was looking for a table with shading on every other row.

Speaking of tables, the border button is the little square icon in the middle. I spent a few moments trying to find it.

Bonus: use dwim-shell-command for quick export

If you’re an Emacs user, you like shortcuts, and you like to use shell commands from within Emacs. If you haven’t yet, check out dwim-shell-command.

Here’s how I have it set up. All I have to do is mark the org file(s) I want to convert to a docx, and that’s it. It doesn’t matter if I want to export only one file or fifty; it’s the same ease of use.

(defun jtr/dwim-shell-command-pandoc-org-to-docx ()
  "uses pandoc to convert an org file to docx using a template docx file. The docx template file is stored in my Notes sync folder"
  (interactive)
  (dwim-shell-command-on-marked-files
   "converting from org to docx"
   "pandoc -s '<<f>>' -o '<<fne>>.docx' --reference-doc ~/Sync/Notes/Info/custom-reference.docx"
   :utils "pandoc"))

Footnotes

¹ : Or, another way to work is to use to select the text you want to modify, then go to Format and select Style from there; you will need to then choose Modify in the window that shows.

Welcome to 2026, and a new year of Emacs Blog Carnival post!

To start the Gregorian calendar year fresh, the blogging/writing/thinking prompt of this month is:

This year, I’ll …

What will you do differently in Emacs this year? Or will you just get started? Why?

What are you excited about to explore and tinker with? What do you want to perfect?

Are there any large projects in front of you that you’ll emacs¹ with confidence?

What’s a Blog Carnival, Again?

A blog carnival is a fun way to tie together a community with shared writing prompts, and marvel at all the creative interpretations of the topic of the month. I’ve provided a couple of interpretations above, but you may think of something else entirely. That’s amazing, roll with it, that’s what makes this fun!

For future Carnivals, check out the “Carnival” page on EmacsWiki . It includes instructions, and is our community space to coordinate participants and topic ideas.

Submissions

Comment below or DM/email me with your submission! I’ll collect submissions up to, and including, February 1st (Central European Time), so that every time zone has had a chance to meet the January 31st deadline.

Ordered by submission date:

• Zimblo: This Year, I’ll de-obfuscate

• George Jones: This Year, I’ll – comes with a handy Emacs verb definition:

  Emacso, -are, -avi, -atus (verb, 1st conjugation)

  emacso, emacsas, emacsat, emacsamus, emacsatis, emacsant

  • Cotidie, cum discipulis meis, emacso ad software melius discendum. (Every day, with my students, I emacs to learn better software.)

• Arjen Wiersma: This Year, I’ll … (“… be taking control of the technologies I use”)
• Sacha Chua: Emacs: This year, I will… / Cette année, je vais…
• John Rakestraw: Emacs Carnival: This year, I’ll …
• Neil Mather: Emacs Carnival: This year I’ll… try, use, improve, …
• Kana: This year, I will write a shitty GUI for my Emacs clone
• Sebastian Larsen Prehn: This year, I’ll move more of my workflows to Emacs
• Lio Novelli: This year I’ll “not reach Emacs/OrgMode Nirvana yet”
• Christian Cleberg: Emacs Carnival: “This Year, I Will…”

Hire me for freelance macOS/iOS work and consulting.

Buy my apps.

Receive new posts via email.