This Irreal post on dependencies and this one on Emacs bloat discussed the idea that many Emacs users have too many packages and other capabilities enabled in their Emacs configuration files. I’ve never worried about that because, really, there’s no reason to do so. Indeed, those who do worry about it mostly fall back on aesthetics as the reason for their worry.

Over at the Emacs subreddit, ptrtoj is complaining that he’s eliminated a lot of packages but his configuration is still over 500 lines long. He’s wondering what else he can do in his quest for a minimal configuration. His post got me thinking explicitly about the value of small configurations and the quest for them.

Here’s a heretical thought: why are minimal configurations a good thing and why should we pursue them? To be sure, every Emacs user eventually accumulates cruft in their configuration: packages they no longer use, workarounds for a bug in Emacs 22 that’s long since been fixed, customizations no longer serving a purpose, and other things they don’t need anymore. No one is arguing that we shouldn’t get rid of the cruft but that’s a bit different from seeking a “minimal configuration” as if it were a good thing per se.

I would argue that on the contrary a large configuration is a sign of users who have—probably over time—made the effort to optimize Emacs for their particular workflow. That a large configuration is, in fact, a sign of a serious—and possibly master—Emacs user.

On reflection, I don’t understand what those desiring a minimal conjuration are seeking or why they’re seeking it. In these days of virtually infinite memory and unlimited CPU power, a minimalism enforced for no clear reason doesn’t make sense.

The outline-indent.el Emacs package provides a minor mode that enables code folding and outlining based on indentation levels for various indentation-based text files, such as YAML, Python, and other indented text files.

In addition to code folding, outline-indent.el allows moving indented sub-trees up and down, promoting and demoting sections to adjust indentation levels, customizing the ellipsis, and inserting a new line with the same indentation level as the current line, among other features.

The outline-indent.el package leverages the built-in outline-minor-mode, which is maintained by the Emacs developers and has less chance of being abandoned like origami.el.

The outline-indent.el Emacs package offers a similar functionality to Vim’s set foldmethod=indent setting. Just as in Vim, it allows to fold and unfold code sections based on their indentation levels.

Installation

To install the outline-indent using straight.el:

1. If you haven’t already done so, add the straight.el bootstrap code to your init file.
2. Add the following code to your Emacs init file:

(use-package outline-indent
  :ensure t
  :straight (outline-indent
             :type git
             :host github
             :repo "jamescherti/outline-indent.el")
  :custom
  (outline-indent-ellipsis " ▼ "))

Usage

Once installed, the minor mode can be activated using:

(outline-indent-minor-mode)

The minor mode can also be automatically activated for a certain mode. For example for Python and YAML:

(add-hook 'python-mode-hook #'outline-indent-minor-mode)
(add-hook 'python-ts-mode-hook #'outline-indent-minor-mode)

(add-hook 'yaml-mode-hook #'outline-indent-minor-mode)
(add-hook 'yaml-ts-mode-hook #'outline-indent-minor-mode)

(You can also adjust the indentation offset by modifying the variable outline-indent-default-offset)

Once outline-indent-minor-mode is activated, you can use the built-in outline-minor-mode functions to fold or unfold indented sections:

• outline-hide-body: Hide all body lines in buffer, leaving all headings visible.
• outline-hide-other: Hide everything except current body and parent and top-level headings.
• outline-hide-entry: Hide the body directly following this heading.
• outline-hide-leaves: Hide the body after this heading and at deeper levels.
• outline-hide-subtree: Hide everything after this heading at deeper levels.
• outline-show-children: Show all direct subheadings of this heading.
• outline-hide-sublevels: Hide everything but the top LEVELS levels of headers, in whole buffer.
• outline-show-all: Show all of the text in the buffer.
• outline-show-entry: Show the body directly following this heading.
• outline-show-subtree: Show everything after this heading at deeper levels.
• outline-show-branches: Show all subheadings of this heading, but not their bodies.
• outline-show-children: Show all direct subheadings of this heading.

You can also indent/unindent and move subtree up and down:

• (outline-indent-demote) and (outline-indent-promote): Indent or unindent the entire subtree.
• (outline-indent-move-subtree-down) and (outline-indent-move-subtree-up) to move the current subtree up or down.
• (outline-insert-heading) to insert a new line with the same indentation level/depth as the current line just before the next heading that shares the same or less indentation level.

In Evil mode, outline-indent-minor-mode works out of the box, and you can use the Evil keyboard mappings: zo, zc, zO, zC, za, zr, and zm to manage folds.

Related links

• outline-indent.el @GitHub

Marcin Borkowski (mbork) has a very interesting post on something I didn’t know about: dedicated windows. The TL;DR is that dedicated windows are restricted—more or less—to the single buffer that they were displaying when they were set to dedicated.

Mbork’s use case is reading a technical book in one window while taking notes and trying code snippets from the book in another. He notes that if there’s an error when executing those code snippets Emacs will open an error window over your book. By marking the window as dedicated, you can avoid that and force Emacs to open a third window so you can see all the pertinent information.

Although dedicated windows have been in Emacs for some time, there’s never been an easy way of invoking them. That changed in Emacs 30. Now’s there a convenient key sequence to mark a window as dedicated (Ctrl+x w d).

To be honest, my workflow doesn’t have much use for this feature but, of course, that can change without warning so it’s nice to know that there’s a way of pinning a window to a particular buffer. If you think that you have a use for such a feature, be sure to take a look at Mbork’s post for the details. The easy UI won’t be available until Emacs 30.1 but you still set a window dedicated by calling the appropriate function. See the documentation for the details.

The level of detail shown in the backlinks buffer can now be toggled on demand. This is done with the new command denote-backlinks-toggle-context. The feature is available as part of the current development target of Denote (version 3.1.0-dev, which I am actively working on).

Below are a couple of pictures, showing a note that (i) has just gotten a backlinks buffer with the denote-backlinks command and (ii) the user interacts with the backlinks buffer to show/hide the context of matching links.

The compact view

This shows the files that link to the current file, one per line. If a file has multiple links, it still counts as one on this list.

The detailed view

In this presentation, each match is displayed in its context, with a reference to the line number it is found at. Multiple links in each file are shown separately and are grouped per file.

The implementation details may change

Remember that this is part of the current development version. I might make further changes to it and I am happy to get your feedback.

Users have long now had the denote-backlinks-show-context option to set their default preference. With current developments, they can still do what they did, plus toggle the view when the need arises.

When will version 3.1.0 be released?

There are no deadlines. Things are in a good state, but I will not rush to make this happen. To give you a rough idea, expect it some time in mid to late August.

About Denote

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

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

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

I just got a notice from Mickey that the latest version of Mastering Emacs is out. It is, when you think about it, a modern miracle. You buy a really great book on Emacs once and keep getting the new editions for free.

This version brings the book up to date as of Emacs version 29. The two megafeatures of version 29 are Tree Sitter for finally rationalizing syntax highlighting and Eglot to provide smart completion and other “modern” IDE-like functionality. But as Mickey says, there are a “million” other, smaller improvements.

Speaking of buying Mastering Emacs, Mickey is having his usual new edition sale on the book. For a little more than the next day, you can get the book for 29% off. If you have any interest at all in Emacs, you really should have this book and now is the perfect time to get it. By the time you read this, the sale will be almost over so act now if you’re interested.

2024-07-23 Eglot for Go, Perl and Markdown

Apparently there’s a way to have Oddµ and Eglot cooperate in Emacs using Marksman.

Note that LSP integration only works in a “project”: a VCS repository, or in the case of Marksman, a directory containing an (empty) .marksman.toml file. This latter option is important if your notes aren’t under version control.

After installing the Marksman binary, use something like the following. This installs Eglot for Go mode, Perl mode and Markdown mode.

;; There is probably a way to put this inside the use-package form but
;; this is how it works for me.
(add-hook 'go-mode-hook 'eglot-ensure)
(add-hook 'perl-mode-hook 'eglot-ensure)
(add-hook 'markdown-mode-hook 'eglot-ensure)
(autoload 'eglot-ensure "eglot" "Start Eglot session for current buffer if there isn’t one.")

(use-package eglot :ensure t
  :config (add-to-list 'eglot-server-programs '(markdown-mode . ("marksman"))))

(setq-default eglot-workspace-configuration
    '((:gopls .
        ((staticcheck . t)
         (matcher . "CaseSensitive")))))

#Emacs #Oddµ #Markdown #Perl #Golang

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

In this ~35-minute video I demonstrate the main features of the ‘use-package’ configuration macro that is built into Emacs 29. It is the de facto standard for setting up packages and is designed to make Emacs faster to start up and more robust overall.

;;; Install a package, if needed

(use-package denote
  :ensure t)

(use-package dired
  :ensure nil)

;;; Evaluate code after a package is loaded

(use-package ef-themes
  :ensure t
  :config
  (ef-themes-select 'ef-cyprus)) ; the theme for this video

;;; Evaluate code before a package is loaded

(use-package corfu
  :init
  (setq tab-always-indent 'complete)
  :config
  ...)

;;; Conditional loading

(use-package spacious-padding
  :ensure t
  :if (display-graphic-p)
  :config
  ...)

;; This is for the sxhkd program, which is used with minimalist tiling
;; window managers.
(use-package sxhkdrc-mode
  :ensure t
  :if (eq system-type 'gnu/linux)
  ...)

(when (eq system-type 'gnu/linux)
  (use-package sxhkdrc-mode
    :ensure t
    ...))

;;; Defer loading by defining keys

(use-package denote
  :ensure t
  :bind
  ("C-c n n" . denote)
  :config
  (setq denote-known-keywords '("emacs" "philosophy" "politics")))

(use-package denote
  :ensure t
  :bind
  ( :map global-map ; same as above
    ("C-c n n" . denote))
  :config
  (setq denote-known-keywords '("emacs" "philosophy" "politics")))

(use-package denote
  :ensure t
  :bind
  ;; For more key bindings, you need a list of such pairs
  (("C-c n n" . denote)
   ("C-c n r" . denote-rename-file))
  :config
  (setq denote-known-keywords '("emacs" "philosophy" "politics")))

;;; Defer loading with a hook

(use-package nerd-icons-dired
  :ensure t
  :hook
  (dired-mode . nerd-icons-dired-mode)
  :config
  ;; Evaluated only after I am in Dired.
  ...)

;;; Defer loading until some command is called (usually not needed)

(use-package bookmark
  :ensure nil
  :commands (bookmark-set bookmark-jump bookmark-bmenu-list))

;;; Defer loading until a file is opened (for major modes)

(use-package sxhkdrc-mode
  :ensure t
  ;; We generally do not need :mode because major modes set this up
  ;; already.
  :mode "sxhkdrc_.*")

;;; Defer loading indefinitely or for N seconds of idleness

(use-package server
  :ensure nil
  :defer 1
  :config
  (setq server-client-instructions nil)
  (unless (server-running-p)
    (server-start)))

(use-package markdown-mode
  :ensure t
  :defer t
  :config
  (setq markdown-fontify-code-blocks-natively t))

;;; Force loading when deferring is not desired

(use-package modus-themes
  :ensure t
  :demand t
  :bind
  (("<f5>" . modus-themes-toggle)
   ("C-<f5>" . modus-themes-select))
  :config
  (modus-themes-load-theme 'modus-vivendi-tinted))

;;; Define many keys in many key maps

(use-package denote
  :ensure t
  :bind
  ( :map global-map

    ("C-c n n" . denote)
    ("C-c n r" . denote-rename-file)

    :map text-mode-map

    ("C-c n i" . denote-link) ; "insert" mnemonic
    ("C-c n I" . denote-add-links)

    :map dired-mode-map

    ("C-c C-d C-i" . denote-link-dired-marked-notes)
    ("C-c C-d C-r" . denote-dired-rename-marked-files)))

;;; Add the same function to many hooks

(use-package abbrev
  :ensure nil
  :hook ((text-mode prog-mode git-commit-mode) . abbrev-mode))

;; This is the same as above, which has the advantage of being easier
;; to make sense of and modify, but is repetitive.
(use-package abbrev
  :ensure nil
  :hook ((text-mode . abbrev-mode)
         (prog-mode . abbrev-mode)
         (git-commit-mode . abbrev-mode)))

;;; Specify a custom `load-path'

(use-package notmuch
  :ensure nil ; do not install, because I get it from my Linux distro packages
  :load-path "/usr/share/emacs/site-lisp/"
  :defer t
  :commands (notmuch notmuch-mua-new-mail))

;;; Load a package after another

(use-package notmuch
  :load-path "/usr/share/emacs/site-lisp/"
  :defer t
  :commands (notmuch notmuch-mua-new-mail))

(use-package notmuch-indicator
  :ensure t
  :after notmuch
  :config
  (notmuch-indicator-mode 1))

;;; Do not force dependencies with `:after'

(use-package register
  :ensure nil
  :defer t ; its commands are autoloaded, so this will be loaded then
  :config
  ;; Use `with-eval-after-load', name the symbol of the feature, and
  ;; then write arbitrary code below.
  (with-eval-after-load 'savehist
    (add-to-list 'savehist-additional-variables 'register-alist)))

;;; Avoid never loading the package with `:bind'

(use-package vertico
  :ensure t
  ;; This is WRONG, because it defers the loading of the package until
  ;; `vertico-directory-delete-char' is invoked.  But this command is
  ;; only accessible through the `vertico-map' which, in turn, is only
  ;; available inside the Vertico-powered minibuffer, i.e. after
  ;; `vertico-mode' is enabled.
  :bind
  ( :map vertico-map
    ("DEL" . vertico-directory-delete-char))
  :config
  (vertico-mode 1))

(use-package vertico
  :ensure t
  ;; This is fine now.
  :hook
  (after-init . vertico-mode)
  :bind
  ( :map vertico-map
    ("DEL" . vertico-directory-delete-char)))

A couple of week ago I wrote about Álvaro Ramírez’s ready player mode. The idea is to be able to take a quick peek at a media file from within Emacs. At the time, the app was still beta quality and not yet on MELPA.

Now, Ramírez has announced that the app is on MELPA and ready for general use. Take a look at Ramírez’s original post to see what it can do and why you might want it. Now that it’s on MELPA, it’s easy to install.

• Upcoming events:
  • Emacs APAC (virtual) https://emacs-apac.gitlab.io/ Sat Jul 27 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
  • Emacs Berlin (virtual, in English) https://emacs-berlin.org/ Wed Jul 31 0930 America/Vancouver - 1130 America/Chicago - 1230 America/Toronto - 1630 Etc/GMT - 1830 Europe/Berlin - 2200 Asia/Kolkata – Thu Aug 1 0030 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Aug 2 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
• Emacs configuration:
  • ~/.emacs for beginners
  • Devilish fun with a modeless modal editing mode (Reddit)
  • [AO VIVO] Configurando o Emacs do zero - parte 1 (01:35:22)
  • [AO VIVO] Configurando o Emacs do zero - parte 2 (01:37:19)
  • [AO VIVO] Configurando o Emacs do zero - parte 3 (01:19:56)
  • ovistoica's Emacs Config
• Emacs Lisp:
  • Writing a simple Emacs major-mode (2021)
  • Announcing Casual RE-Builder (Reddit, Irreal)
  • Emacs Regexps: The Small Print (Reddit, Irreal)
  • The right way to handle case-insensitive inputs with `completing-read`
  • A number of Emacs Lisp math libraries
  • Introducing elispcomp: Compiling Elisp code directly from the command line (Reddit)
  • Xah Talk Show Ep563, Emacs Lisp Coding move-html-text-block and random chat (01:12:20)
  • Unwound Stack: fill-column-indicator - use display-fill-column-indicator-mode instead
• Appearance:
  • James Dyer: Selected Window Accent Mode v0.8.0
• Navigation:
  • Emacs: Enhancing up and down subtree movement in outline-mode and outline-minor-mode (Reddit)
  • persp-project - project.el integration for perspective.el
  • Emacs Buffer Transpose 2024_07_20_03:20:45 (04:27)
• Writing:
  • Efficient LaTeX Editing With Emacs - Michael (2023, HN)
  • J.e.r.e.m.y B.r.y.a.n.t: preview-auto in LaTeX buffers
• Org Mode:
  • Using Org Mode With Hugo · weblog.masukomi.org (Reddit)
• Completion:
  • How to make consult-history work for git commits and ERC buffers
  • Announcing consult-omni: A powerful omni-search and launcher in Emacs (like Spotlight or Alfred but in Emacs) (Reddit)
• Coding:
  • cognitive-complexity: a treesit-based package to display cognitive complexity of code in Emacs (port of the tree-sitter based codemetrics)
  • Martin / devhelp2.el · GitLab - read devhelp in Emacs (@debacle@framapiaf.org)
  • A Fair Trial of Emacs' Version Control Mode - System Crafters Live! (02:02:14)
• Mail, news, and chat:
  • Read email with Notmuch | Cool Emacs (2023)
  • Magnus: Emacs via Nix with mu4e
• Evil mode:
  • init-evil.el · GitHub
  • Minimal Emacs configuration for Windows and Mac (Vim bindings and leader key) · GitHub
• Doom Emacs:
  • Doom Emacs on WSL FULL GUIDE (03:26)
  • Replay - Writing elisp for doom emacs config | emacs-evil (01:06:36)
  • [Emacs] Instalação do Doom Emacs e projetos (02:01:21, bolha.tube)
• Multimedia:
  • Never fear mistakingly opening media files ;) Ready Player Mode now on MELPA (Reddit)
  • subed code for moving start time and jumping to it
• AI:
  • ekg version 0.6.0: now with LLM context
• Community:
  • Weekly Tips, Tricks, &c. Thread
  • Irreal: Learn Vim or Emacs
  • James Dyer: Emacs Blog 2 Year Anniversary - First Post Revisit - Create Local Offline ELPA MELPA ORG
• Other:
  • Mickey Petersen: The Emacs 29 Edition of Mastering Emacs is out now (HN)
  • Alvaro Ramirez: OCR those buffers (Reddit)
  • Makros in Vim und Emacs (Regex, Teil 3) - LinuxCommunity (@hofmannedv@mastodon.social)
  • A solution for getting Emacs to compile with tree-sitter on Fedora
  • Emacs too slow. - Windows; some tips in the discussion (More tips)
  • Catalina and Emacs
  • Buttery Smooth Emacs - Mirror of Daniel Colasciones great blog post about emacs' inner workings · GitHub (2016)
• Emacs development:
  • emacs-devel:
    • Long discussion about including a mathematical library, possibly exposing more functions from libm
    • Re: Markers in a gap array - status of scratch/igc branch with MPC
    • Re: MPS: assertion failed: header_type (h) != IGC_OBJ_FWD - more info on symbol alignment
  • Add commands to run unit tests in 'go-ts-mode'
  • Work around GCC bug 58416 on 32-bit x86
  • Allow specifying stdout/stderr separately in some Eshell commands
  • Add history variables for find-func entry points
• New packages:
  • evil-neo: Minor mode for using the Neo keyboard layout with Evil (MELPA)
  • helm-roam: Helm command for org-roam (MELPA)
  • ready-player: Open media files in ready-player major mode (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Mastodon #emacs, Hacker News, lobste.rs, programming.dev, lemmy, communick.news, 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!

It’s taken a little bit longer than I would have liked to get the next edition out the door. I also felt the site needed a lick of paint which, if you’re a regular and astute reader, you may have noticed already.

But as I explain in the book update below, the two headline features are tree-sitter support and Eglot. To say nothing of the million other new Emacs 29.1 features that were added.

A couple of years ago, I wrote about Tree Sitter and the Complications of Parsing Languages. In it, I talk about the immense difficulties around parsing languages in a way that is both useful and consistent for a wide range of programming languages and structured texts. Tree-sitter is one of the few that have managed to cross that chasm; no small feat, in my opinion.

The other major inclusion is Eglot. It’s another smart and sensible addition to Emacs core. Combined with tree-sitter, you now have access to top-notch syntax highlighting and IDE-like features right out of the box.

As always, to celebrate the release of the new edition of the book, I have put it on sale with a 29% discount.

2024 Edition Update

This is 2024 Edition update the excerpt from the book.

Emacs 29 continues the long-running trend of keeping up with advances in technology. That is commendable. Emacs is an old piece of software, and yet it is continuously improving.

One of the hardest things to get right in a text editor is syntax highlighting (font locking in Emacs parlance) and writing a robust indentation engine. You see, when Emacs – and many other editors, old and new – syntax highlight your source code, they do so using regular expressions, a terse method for matching text using pattern matching. Regular expressions are great; they’re a succinct way of matching and extracting important information from text. They are the backbone of syntax highlighters nearly everywhere, but they also have a flaw: they can be imprecise, and can impede performance if they are poorly written.

A regular expression also cannot contextualize what it is matching: just that it did (or did not) match something. For a wide range of granular tasks, it is simply not possible to rely on regular expressions. That is a problem as you want as much precision as you can get. Yet it’s often impossible to tell some things apart with a regular expression, such as whether a series of characters is a variable or a function call. The same series of characters may have one meaning in one context, and an altogether different one in another. Regular expressions are rarely powerful enough to capture that nuance. And so most text editors build their syntax highlighting and indentation engines with a medley of regular expressions and hand-tuned, imperative code to try to work around the limitations of the former.

Good news, then, as Emacs 29 adds optional support for tree-sitter, a parser library with an exacting eye for source code parsing that constructs a Concrete Syntax Tree from any text for which it has a valid grammar. Such a tree is the perfect medium for a computer (or willing user) to query. It makes correct syntax highlighting possible with little more than a few dozen lines of code. It also adds the tantalizing promise of structured editing and movement, a sprawling concept that reuses the tree-like structure tree-sitter yields to offer unparalleled editing and movement in your code base.

Tree-sitter’s not the only game in town. What it does bring to the table, and what has eluded most other attempts (in Emacs and beyond), is that is has the largest repository of parsers for both common and uncommon languages and structured text files. Tree-sitter is thus capable and popular. It helps that it is quite straightforward to write your own parser using tree-sitter’s tooling. The cherry on top is a query language to quickly find and match segments of the parsed tree that it emits. That is perhaps its ace in the hole: being able to ask it to show you (for example) all the functions that contain one or more variables with a given name is a powerful feature indeed. Modeled on LISP’s S-expressions, the query language also feels right at home in an Emacs ecosystem.

Presently, the feature is optional, as you must compile Emacs with tree-sitter support. So it is unlikely to replace, wholesale, the existing major modes and the old way of doing things. But it’s a large step forward for Emacs, as it makes writing syntax highlighting and indentation code downright easy. Its adoption into Emacs core is a positive development, and a repudiation against the entrenched belief that Emacs can never fundamentally change. Font locking in Emacs was first introduced around 35 years ago, and now there is a new way – and often much better way – than the old regular expressions. Its successful integration into Emacs is also reflected in the wider Emacs community where it has proven to be a popular feature, despite the fact that tree-sitter is, being new to Emacs, cumbersome to set up and use.

The other major inclusion is Eglot, a client that understands the language server protocol (LSP). Eglot adds IDE-like features to any buffer for which there is a language server available. It’s designed to work with nothing more than base Emacs and the requisite language server. Provided you’ve got your language server set up, all you need to type is M-x eglot (or select Tools -> Language Server Support) to get started. Eglot’s been around for a long time on ELPA, an Emacs package repository. Now it’s built into Emacs.

Both capabilities are capstones in an otherwise packed release full of exciting improvements and fixes. If you’re not using Emacs 29 already, you should definitely upgrade.

For better or worse, the CCE now runs on River WM

I recently wrote about Casual RE Builder, one of Charles Choi’s Casual Suite apps. As I wrote then, it goes a long ways towards making RE-builder usable for those of us who can’t remember all the commands necessary to export the resulting regex to a useful place.

While he was working on Casual RE-builder, Choi discovered that sometimes—usually in the Dired subsystem—Emacs expects “grep-like” regular expressions rather than the Emacs style. This is undoubtedly because Emacs outsources certain tasks to external grep routines. The fact that the particular regexp subset used depends on what flavor of grep you have installed makes things even more complicated. If you’re like me, all of this is news to you. Somehow, I’ve managed to stumble through using Dired without realizing that it was pulling a bait-and-switch on me.

Regardless, Choi has come to the rescue. He’s changed Casual RE-builder to add an option to export the regexps from RE-builder in grep format. It’s a small thing but it makes Casual RE-builder even more useful.

I’ve already installed Casual RE-builder and presumably I’ll get Choi’s latest changes with my next update. This is, I say again, a really useful package and if you use regexps at all in Emacs, you should take a look at it.

Just removed fill-column-indicator from my Emacs configuration

I've been running development versions of Emacs ever since I switched to Wayland and needed the PGTK code. The various X-git packages on AUR makes that easy, as long as one doesn't mind building the packages locally, and regularly. Building a large package like Emacs does get a bit tiring after a while though so I started looking at the emacs overlay to see if I could keep up without building quite that much.

The first attempt at this failed as I couldn't get my email setup working; emacs simply refused to find the locally installed mu4e package. I felt I didn't have time to solve it at the time, reverted back to doing the builds myself again. It kept irritating me though, and today I made another attempt. This time I invested a bit more time in reading up on how to install emacs via Nix with packages. Something that paid off.

I'm managing my packages using nix profile and a flake.nix. To install emacs with a working mu4e I started with adding the emacs overlay to the inputs

inputs = {
  nixpkgs.url = "github:nixos/nixpkgs?ref=nixpkgs-unstable";
  ...
  community-emacs.url = "github:nix-community/emacs-overlay";
};

and in my outputs I made sure to use the overlay on nixpkgs

outputs = inputs@{ nixpkgs, community-emacs, ... }:
  let
    system = "x86_64-linux";
    pkgs = import nixpkgs {
      inherit system;
      overlays = [ community-emacs.overlays.emacs ];
    };
    ...

and in the list of packages passed to pkgs.buildEnv I added

...
((emacsPackagesFor emacs-pgtk).emacsWithPackages
  (epkgs: [ epkgs.mu4e ]))
mu
...

That's all there's to it. After running nix profile update 0 I had a build of emacs with Wayland support that's less than a day old, all downloaded from the community cache. Perfect!

When editing outlined files (e.g., using the built-in outline-minor-mode, or packages like outline-indent.el, outline-yaml.el, etc.), handling subtrees efficiently can significantly enhance productivity, especially when working with complex documents. If you’re familiar with outline-mode or outline-minor-mode, you might have noticed that the built-in functions for moving subtrees up and down, outline-move-subtree-up and outline-move-subtree-down:

• Blank line exclusion: outline-move-subtree-up and outline-move-subtree-down exclude the last blank line of the subtree when the outline-blank-line variable is set to t. Setting outline-blank-line to t is worthwhile because it retains a visible blank line after the subtree and before the next heading, improving the readability of the document.
• Cursor position reset: After moving a subtree up or down, the cursor position is often reset, which can be disruptive during editing.

Here’s how you can address these issues by using custom functions to enhance subtree movement:

(require 'outline)

(defun my-advice-outline-hide-subtree (orig-fun &rest args)
  "Advice for `outline-hide-subtree'.
This ensures that the outline is folded correctly by
outline-move-subtree-up/down, preventing it from being unable to open the fold."
  (let ((outline-blank-line
         (if (bound-and-true-p my-outline-hide-subtree-blank-line-enabled)
             my-outline-hide-subtree-blank-line
           outline-blank-line)))
    (apply orig-fun args)))

(defun my-advice-outline-move-subtree-up-down (orig-fun &rest args)
  "Move the current subtree up/down past ARGS headlines of the same level.
This function ensures the last blank line is included, even when
`outline-blank-line' is set to t. It also restores the cursor position,
addressing the issue where the cursor might be reset after the operation."
  (interactive "p")
  (let ((column (current-column))
        (outline-blank-line nil)
        (my-outline-hide-subtree-blank-line-enabled t)
        (my-outline-hide-subtree-blank-line outline-blank-line))
    (apply orig-fun (or args 1))
    (move-to-column column)))

(advice-add 'outline-hide-subtree
            :around #'my-advice-outline-hide-subtree)
(advice-add 'outline-move-subtree-up
            :around #'my-advice-outline-move-subtree-up-down)
(advice-add 'outline-move-subtree-down
            :around #'my-advice-outline-move-subtree-up-down)

I also recommend using Ctrl-Up and Ctrl-Down key bindings for moving subtrees up and down.

(define-key outline-mode-map (kbd "C-<up>") 'outline-move-subtree-up)
(define-key outline-mode-map (kbd "C-<down>") 'outline-move-subtree-down)

(defun my-setup-outline-minor-mode-keybindings ()
    "Set up keybindings for moving subtrees in `outline-minor-mode'."
  (define-key outline-minor-mode-map (kbd "C-<up>") 'outline-move-subtree-up)
  (define-key outline-minor-mode-map (kbd "C-<down>") 'outline-move-subtree-down))
(add-hook 'outline-minor-mode-hook 'my-setup-outline-minor-mode-keybindings) 

With this setup, you will ensure that every time you use outline-move-subtree-up or outline-move-subtree-down, the last blank line of the subtree is included and the cursor position is restored.

As I write this, I am imagining one of those slightly cheesy voiceovers for a TV show, reminding viewers of the previous episode: “Last time on ‘BSAG Gets Nerdy About Emacs’…”. You may remember that I was on the Emacs from Scratch cycle again, and enjoying the process of learning the default Emacs keybindings, instead of installing evil-mode like I usually do. Well, I am still doing that, but a random meander around the Emacs-y corners of the internet turned up susam’s devil-mode, a sort of modeless modal editing mode. A what now?

The elispcomp command line tool allows compiling Emacs Lisp (Elisp) code directly from the terminal or from a shell script. It facilitates the generation of optimized .elc (byte-compiled) and .eln (native-compiled) files, which can significantly improve the performance of Emacs.

The tool executes a headless instance of Emacs that recursively scans the specified directories, byte compiling and native compiling all the .el files that haven’t been compiled yet. It supports various configuration options, allowing you to adapt the compilation process to suit your needs.

When configured appropriately, Emacs can compile to both .elc and .eln files. However, for those who wish to automate the background compilation of .el files using a script, the elispcomp command-line tool can be beneficial in ensuring that their Emacs setup remains up-to-date without manual intervention and without starting an Emacs instance. I personally use elispcomp compile multiple Elisp files across various machines and Emacs versions.

Installation

To get started with elispcomp, you can install it using pip, Python’s package installer. Here’s how:

pip install --user elispcomp

This command installs elispcomp and places the executable in your ~/.local/bin/ directory, making it easily accessible from your command line.

Usage

The elispcomp command line tool is straightforward to use.

First example: To compile all .el files located in the ~/.emacs.d/lisp:

elispcomp ~/.emacs.d/lisp

Second example: To compile all .el files located in the ~/.emacs.d/lisp directory, and store the native-compiled files in the ~/.emacs.d/eln-cache directory:

elispcomp --eln-cache ~/.emacs.d/.eln-cache ~/.emacs.d/lisp

Command line options

usage: elispcomp [--option] [N]

Recursively byte and native compile .el files.

positional arguments:
  N                     The directories to be scanned recursively by Emacs to 
                        locate the '.el' files for compilation.

options:
  -h, --help            show this help message and exit
  -c ELN_CACHE, --eln-cache ELN_CACHE
                        The eln-cache directory where Emacs stores the
                        compiled native compiled code. Defaults to the
                        default Emacs eln-cache directory.
  -e EMACS_BIN, --emacs-bin EMACS_BIN
                        Path to the Emacs binary. Defaults: emacs
  -j JOBS, --jobs JOBS  Specify the number of parallel jobs for compilation.
                        Default: Half the number of available CPUs
  -b, --disable-byte-comp
                        Disable byte-compile. Default: enabled
  -n, --disable-native-comp
                        Disable native compilation. Default: enabled
  -i LOAD_PATH, --load-path LOAD_PATH
                        Recursively adds the subdirectories of the specified
                        directory to the Emacs `load-path`. This option can
                        be used multiple times to include several directories.

The elispcomp command-line tool offers an alternative approach to managing Emacs Lisp code. Try it out and experience a new way to compile your Elisp codebase from the command line or from a script.

Links

• elispcomp @GitHub
• elispcomp @PyPI

Whats New

What’s New in Selected Window Accent Mode v0.8.0 - (selected-window-accent-mode) which is my window accent package in MELPA for Emacs, here is a quick summary before I dive into the new features:

The Selected Window Accent Mode is an Emacs package designed to visually distinguish the currently selected window by applying a unique accent color to its fringes, mode line, header line, and margins.

https://github.com/captainflasmr/selected-window-accent-mode

Transient Map for Quick Access

In the latest release of Selected Window Accent Mode, version 0.8.0, users of Emacs 28.1 and above can enjoy the convenience of a transient map. This new feature allows you to access a transient menu by simply pressing `C-c w`:

(global-set-key (kbd "C-c w") 'selected-window-accent-transient)

Upon invoking this key binding, the following transient menu will be displayed:

Release Highlights

v0.8.0 | 2024-07-15

• Transient Menu: A transient menu has been added for interactive adjustments, simplifying the process of tweaking settings on the fly. Refer to the README for detailed usage instructions.
• Emacs Dependency: The Emacs dependency has been upgraded to version 28.1.
• Custom Foreground Accent Color: A new variable, `selected-window-accent-fg-color`, has been introduced for setting a custom foreground accent color.
• Enhanced Customization Options:
  • `selected-window-accent-foreground-adjust-factor`
  • `selected-window-accent–use-complementary-color`
  • `selected-window-accent–foreground-invert-state`
  • `selected-window-accent–foreground-offset`
• Foreground Brightness Functions:
  • `selected-window-accent-flip-foreground-color`
  • `selected-window-accent-increment-foreground-color`
  • `selected-window-accent-decrement-foreground-color`
  • `selected-window-accent-toggle-complementary-color`
  • `selected-window-accent-toggle-tab-accent`
  • `selected-window-accent-toggle-smart-borders`
• Configuration Export: A new function, `selected-window-accent-output-selected-window-accent-settings`, allows you to output the current settings for easy copying and pasting into your Emacs init file.
• Miscellaneous: Various improvements and refactoring have been made to enhance the overall functionality and maintainability.

v0.7.0 | 2024-07-09

• Compatibility Fixes: Addressed issues with other packages and restored modeline height when switching between modes.
• Issue Resolutions:
  • ISSUE #4: Resolved compatibility issues with other packages.
  • ISSUE #3: Fixed problems causing the package to break fringes.

With these updates, Selected Window Accent Mode continues to offer increased customization and improved user experience. Stay tuned for more exciting features in the upcoming versions! 😀

With my recent work with Casual RE-Builder, I found to my surprise that not all Emacs regexp commands take an Emacs-style regexp. 🤯

Apparently some commands take a grep-style of regex like dired-do-find-regexp and dired-do-find-regexp-and-replace. For such commands, the regexp syntax is dependent on the type of grep that is installed and configured for use by Emacs. If you are using GNU grep, the good news is that the regexp syntax is largely the same as Emacs.

I qualify this as largely because with interactive commands, the escaping rules are different between Emacs and grep-style regexps. I suspect this has only added to the frustration of using plain RE-Builder which only provides export for a Emacs-style regexp to be used in code.

To alleviate this, Casual RE-Builder now has a new command to export specifically to interactive grep-style regex commands. This presumes that the GNU grep is being called.

Also the search & replace menu in Casual Dired has been modified to highlight such grep-style regex commands.

One last note: While I’ve taken effort to verify that this new command is doing all the right escaping, I would not be surprised if it has bugs. Because Elisp does not have support for raw strings like Python and Swift, I’m at a loss to know how to write a unit-test to automate its verification. For now I’m doing it manually, with test regexps that hopefully cover enough escaping behavior. If you find a bug, please report an issue with your regexp and the target text so I can troubleshoot. I’d also qualify that my knowledge of Elisp regexps is not that deep. I’d be happy to get guidance from more enlightened readers.

With all that said, I invite you to try this new feature out in Casual RE-Builder. I think you’ll be delighted that you did.

Kris Brandow has a (very) short video—I think it’s part of a podcast—advancing the idea that you should learn Vim or Emacs. Irreal, of course, is not going to argue with that but I wish he’d given more reasons why you should. What he does say is that you’ll discover you can be more productive with Vim or Emacs than you can with an IDE but doesn’t explain why that is. You should, he says, just try them.

One of the other people on the video objected that you don’t “just try” Emacs. It’s a commitment that takes dedication and effort to learn. That is certainly true of Emacs as we all know but it’s true of Vim as well. It’s not as hard to master as Emacs but there’s a surprising amount to know before you can consider yourself to have mastered it. That’s the problem with saying, “Just try it.” You won’t see real benefits from either editor until you’ve put a some time and effort into learning them.

The most depressing thing about the video is that Brandow described his suggestion as an “unpopular opinion”. I suppose that it might be unpopular among a certain segment of our community but there are also those who think that Javascript is a great, well thought out programming language. Ours is nothing if not a vibrant community with a diversity of opinion.

Álvaro Ramírez has a very revealing post about the compounding benefits of learning a bit of Elisp. Studying how Emacs works and learning its various features pays huge dividends but, says Ramírez, learning some Elisp can compound those dividends and enable you to mold Emacs to a tool hyperspecialized to your needs.

He starts by postulating two features that you realize would be even more useful if you could somehow combine them. Then he gives a specific example. He considers the two packages symbol-overlay and multiple-cursors. The symbol-overlay package highlights all occurrences of the symbol under point in the current buffer and, of course, multiple-cursors lets you perform the same operation in multiple places at the same time.

He uses them both all the time but realized that it would be very handy if he could invoke multiple-cursors with a cursor on each occurrence of the symbol under point. He needed, in short, to combine the action of symbol-overlay and multiple-cursors.

That turns out to be fairly easy if you know some Elisp. Ramírez walks us through how he figured out how to do it and shows the Elisp that does it. There’s not a lot of code (about 20 lines), it’s easy to understand, and it serves as a great example of how a bit of Elisp can work magic. Finally, he made an animated GIF that shows it in action.

This is a nice post and it provides some code that you may find useful for your own workflow. Take a few minutes to give it a look.

Charles Choi has another great addition to his Casual Suite. This time it’s an interface to the re-builder command. There are two things that everyone agrees about Emacs regular expressions:

1. They’re very powerful and useful
2. They have an arcane syntax and are hard to use

Well really, they’re not that much different from other RE syntaxes but there is enough difference to make using them harder than it should be. Indeed, many folks who everyone would agree are master Emacs users constantly bemoan the RE syntax and wish it were replaced with something else such as Perl Compatible REs.

Happily, there’s a tool, re-builder, that can help. I’ve written about it here and here. Unhappily, I find it really hard to use. Finding a good regexp is easy enough but it’s hard to remember how to export that regexp for use in your code or the current command.

That’s where Choi’s Casual RE-builder comes in. Like other members of the Casual Suite, when you need to remember some of the arcane commands, you can simply invoke a handy transient menu to remind you.

As much as I like re-builder, I almost never use it because I can never remember how to export the resulting regexp to where I need it. Choi’s RE-builder solves this problem and, to my mind, increases the utility of re-builder a great deal.

If you have troubles with Emacs regexs or have found re-builder too hard to use, you should take a look at Choi’s RE-builder app.

I’ve noticed that my Emacs blog is now almost 2 years old!

Is there something absurd about writing about a text editor in that very text editor for such a long period? - I think the answer to this is clearly…, no!

My first post was on 2022-07-15 and this will be blog number 97.

And yes before you ask, how do I know this to be true?, well I found out the Emacs way!

I recorded its inception date in org-agenda, so I saw this date creep up this week :

** blog anni :james:web:
<2022-07-15 .+1y>

The date of my first post is in an org drawer in my single Emacs blog org file:

:EXPORT_HUGO_LASTMOD: 2022-07-15

and the blog number?, well, I org-copy-visible’d my org blog file of all the top level org headers, pasted into the scratch buffer, flush-line’d out all the TODO entries, then finally entered (display-line-numbers-mode) to get the number of lines (I suspect there might be an easier way to do this 😀)

I also wrote this post ahead of time and to remind me when to post I created an org schedule entry as follows:

** TODO post 2 yr emacs blog post
SCHEDULED: <2024-07-15 Mon>

and appeared in the agenda as :

Monday     15 July 2024 W29
  aab--calendar:Scheduled:  TODO post 2 yr emacs blog post

and in (cfw:open-org-calendar) as :

+-------------------------+
| 15 (3)                  |
| TODO post 2 yr emacs    |
| blog anni               |
|                         |
|                         |
|                         |
+-------------------------+

Living an Emacs life and especially partially through org means that any and all information can be easily extracted let alone initially logged, the basic text format is so simple and uniform that all the data items above were pretty much extracted using the same mechanism through Emacs.

Anyway enough of all that, in celebration of being able to maintain some level of blogging discipline for 2 years, I decided to revisit my very first post, which was on how to create an offline version of the major Emacs repositories, namely:

• ELPA
• MELPA
• ORG

As it turns out this post is still quite relevant as from time to time, I need an offline version for an Emacs setup without an internet connection.

So lets re-post!, just for fun!, including the bash script that I still use:

Steps to locally download emacs packages for offline installation.

Local ELPA MELPA ORG

#! /bin/bash
cd ~
mkdir -p emacs-pkgs/melpa
mkdir -p emacs-pkgs/elpa

echo
echo "updating MELPA..."
echo
rsync -avz --delete --progress rsync://melpa.org/packages/ ~/emacs-pkgs/melpa/.

echo
echo "updating ELPA..."
echo
rsync -avz --delete --progress elpa.gnu.org::elpa/. ~/emacs-pkgs/elpa

# org (currently no rsync support)
echo
echo "updating ORG..."
echo
cd ~/emacs-pkgs
git clone https://git.savannah.gnu.org/git/emacs/org-mode.git
# wget -r -l1 -nc -np https://orgmode.org/elpa

I then copy the emacs-pkgs directory to the offline target machine and change the default package manager archives to point to these packages.

Modify .emacs in the following manner commenting out the online package communication:

;; (setq package-archives '(("melpa" . "https://melpa.org/packages/")
;;                          ("org" . "https://orgmode.org/elpa/")
;;                          ("elpa" . "https://elpa.gnu.org/packages/")))

(setq package-archives '(("melpa". "~/emacs-pkgs/melpa")
                          ("org" . "~/emacs-pkgs/elpa")
                          ("elpa" . "~/emacs-pkgs/org-mode/lisp")))

Knowing how to use regular expressions (regexp) is a superpower. While there are many different variants of regexp syntax, in Emacs the reward is handsome if you put in the effort to learn its flavor of it. Emacs has many interactive commands that take in a regexp argument. Here’s a small sample:

dired-do-copy-regexp, dired-do-find-regexp , dired-do-find-regexp-and-replace , dired-do-hardlink-regexp , dired-do-isearch-regexp , dired-do-query-replace-regexp , dired-do-rename-regexp , dired-do-search , dired-do-symlink-regexp , dired-flag-files-regexp , dired-isearch-filenames-regexp , dired-mark-files-containing-regexp , dired-mark-files-regexp , ibuffer-do-isearch-regexp , ibuffer-do-query-replace-regexp , ibuffer-mark-by-content-regexp , ibuffer-mark-by-file-name-regexp , ibuffer-mark-by-mode-regexp , ibuffer-mark-by-name-regexp , isearch-backward-regexp , isearch-forward-regexp , isearch-highlight-lines-matching-regexp , isearch-highlight-regexp , isearch-query-replace-regexp , query-replace-regexp

Emacs has a built-in tool called RE-Builder that makes it easier to learn and construct regexps. Invoked by the command re-builder, this creates a small editable window where you can interactively enter a regexp and see matches (if any) highlighted in a target buffer, typically the last one you were working on. While it’s nice to have around, recalling its command set can be a chore which makes it an ideal candidate for Casual.

Announcing Casual RE-Builder now on MELPA as part of the Casual Suite of Emacs porcelains. Install this as an individual package or if you already have Casual Suite installed, update your packages and you’ll automatically pick this up.

Notable Features

• Easy access to regexp syntax documentation.
  • The less friction it takes to figure out the right syntax, the further along you are to having your desired regexp.
• Export regexp for interactive use.
  • Basic RE-Builder only supports exporting a regexp to use in Elisp code. This regexp unfortunately can not work when entered interactively because of character escaping. Casual addresses this by providing support for exporting a regexp that can be used interactively.

Usage

Basic Usage

When the command re-builder is invoked, a buffer named “✳︎RE-Builder✳︎” is created. Activate Casual RE-Builder with the binding C-o (or one of your preference).

At the top of the menu shows the title “RE-Builder” with the target buffer enclosed in parenthesis. The regexp pattern will be applied to the target buffer. The target buffer can be changed with the (b) Target buffer menu item.

Emacs supports three different regexp syntax: 1) read, 2) string, 3) Rx. Use the (x) Syntax menu item to alter it. The current syntax is shown in parenthesis.

If multiple sub-expressions are in the regexp pattern, then they can be observed via the (s) Subexp mode menu item.

If the regexp pattern entered in the “✳︎RE-Builder✳︎” finds multiple matches, a match can be navigated to via the (p) Previous and (n) Next menu items.

Exporting the Regexp Pattern

Once a desired regexp pattern is defined, there are two menu items that can be used to export (copy) it to the kill-ring for further use.

• (w) Interactive will copy the regexp to the kill-ring so that it can be yanked in an interactive command that requires a regexp (e.g. query-replace-regexp).
  • This should only be used when the regexp syntax is set to string.
  • ❗️When yanking (typically C-y) a regexp into an interactive prompt, you must have the point/focus in the minibuffer prompt (typically via mouse). Otherwise the desired content can be altered with extra escaping.
• (c) Code will copy the regexp to the kill-ring so that it can be yanked into a Elisp code that requires a regexp argument.

Regexp Syntax Help

The menu item (i) will invoke the Info page for regexp syntax with respect to the current syntax type.

Quitting RE-Builder

Select (q) Quit to exit the RE-Builder tool.

Closing Thoughts

While I’ve known and used RE-Builder for years, it has never been an “essential” tool to me because it was so clumsy to orchestrate its output with other interactive regexp commands. Add to that the inertia to learn yet another regexp variant and ultimately it would result in me overlooking Emacs commands that used regexp arguments.

Adding interactive export and orchestrating it with the regexp commands in Casual Dired and Casual IBuffer has been an eye-opening and exhilarating experience. With the above I can now do multi-file refactoring in Emacs with confidence. Before Casual RE-Builder, this would of been both a heroic and unthinkable notion.

If you’re like me and are most familiar with Perl Compatible Regular Expressions (PCRE) (for yours truly, the Python library re in particular), it won’t be too much of a stretch to understand Emacs regexps. My recommendation is to jump in! The reward will be a whole universe of Emacs regexp commands that will become available to you to use at your discretion.

References

• Regular Expressions (GNU Emacs Lisp Reference Manual)
• re-builder: the Interactive regexp builder - Mastering Emacs
• PCRE - Perl Compatible Regular Expressions
• re — Regular expression operations — Python 3.12.4 documentation

Just a quickie from something that I’ve had in the queue for a while. Chris Maiorana has a short post on relative line numbers. The idea is that the current line—the line you’re on—is considered line 0 and the lines above and below it are labeled as the number of lines away from the current line.

That’s handy if you’re interested in, say, 5 lines above or below the current line because they’re labeled as that. I love the idea but, truth to tell, I have never found a compelling use case for them. Maiorana says it handy for authors who want to know how many lines there are in the current paragraph but offers no other reason to adopt them.

Still, lots of people seem to like them and they’re certainly easy to turn on. Take a look at Maiorana’s post for the details.

• Upcoming events:
  • Emacs APAC: Announcing Emacs Asia-Pacific (APAC) virtual meetup, Saturday, July 27, 2024
  • M-x Research: TBA https://m-x-research.github.io/ Wed Jul 17 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • EmacsSF: Emacs Lisp Hacking Night: Parsers! (Hybrid) https://www.meetup.com/emacs-sf/events/302146884/ Thu Jul 18 1800 America/Vancouver - 2000 America/Chicago - 2100 America/Toronto – Fri Jul 19 0100 Etc/GMT - 0300 Europe/Berlin - 0630 Asia/Kolkata - 0900 Asia/Singapore
  • Emacs APAC (virtual) https://emacs-apac.gitlab.io/ Sat Jul 27 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
• Beginner:
  • Know Thy Emacs 2024_07_11_04:30:20 - finding out more about Emacs
• Emacs Lisp:
  • Alvaro Ramirez: Inline previous result and why you should edebug (Reddit, Irreal)
  • Lars Ingebrigtsen: I Should Have Implemented The Emacs Inputs Correctly The First Time
  • Wrap any command -line tool into Emacs commands (Reddit)
  • Lightning Talk: Compiling Emacs Lisp to Native Code (06:49)
  • Lightning Talk: Visual Stepper for Emacs Lisp (05:44)
  • Casting Spels in Emacs (@pkal@emacs.ch)
• Appearance:
  • Consistent, Dynamic Access to Your Current Emacs Theme's Palette (Reddit)
  • Running different themes on GUI Emacs and TTY emacsclient, in the same process (Reddit, @genehack@dementedandsadbut.social)
• Navigation:
  • Using new emacs features to replicate other packages: tree-sitter + transient + repeat-mode = expand-region
  • Magnus: A function for jumping to a project TODO file
  • `one-tab-per-project` (aka. `otpp`), workspace management via a thin layer between built-in `project` and `tab-bar`
  • Announcing Casual IBuffer (Reddit, Irreal)
  • Marcin Borkowski: Dedicated windows
  • Feed symbol overlays to multiple cursors (Reddit, Irreal)
  • Inserting numbers with Emacs multiple cursors (2019)
  • Emacs's counsel-M-x meets multiple cursors (2020)
• Writing:
  • Some useful Elisp for writing prose (Reddit)
  • Package go-translate update to v3 (Reddit)
  • James Dyer: Creating a Spelling Transient (Irreal)
• Org Mode:
  • Emacs. But why? (51:20)
  • Automating Org Mode Tasks with Emacs Lisp - System Crafters Live! (02:00:53)
  • Clock Tables - Org Mode, Plain Text, and AI
  • Contact management with Emacs, org-mode, org-contacts, notmuch and org-roam
  • A checkbox list in org-mode with one value (2015)
  • I am keeping an up to date ob-http fork (Reddit)
  • Protesilaos Stavrou: Emacs: Tell Org which linked files to open externally
  • Org development:
    • org-refile: Push point to Org mark ring before jumping
    • ox-beamer: Allow setting frame subtitle with headline property
    • orgtbl-to-generic: Retain special rows in code block table output
    • ox: New custom option to disable macro replacement
• Completion:
  • Confused implementing programmed completion? A snippet to get you started
  • Anand Tamariya: Annotate completion candidates (GNU Emacs) (Reddit)
• Coding:
  • linking to a different git branch (@dotemacs@mastodon.xyz)
  • Making Emacs Work with Project's ESLint
  • Emacs Scala Eglot TreeSitter Nix setup using Home Manager in 2024 - roast my video (13:09, Reddit)
  • Emacs Flutter + Dart Eglot TreeSitter Nix setup using Home Manager
• Evil mode:
  • Emacs Evil: Disabling the automatic removal of spaces after leaving Insert mode (Reddit)
• Multimedia:
  • Ready Player Mode update (Reddit)
• AI:
  • elisa 1.0.0 - ellama retrieval-augmented generation
  • shishimaru/gemini-code-completion.el: Code completion with Google Gemini for Emacsen (Reddit)
  • Github copilot chat in emacs (Reddit)
  • Create your own Emacs ChatGPT in less than 100 LOC!
• Community:
  • Weekly Tips, Tricks, &c. Thread - buffer-local keys, precision-scroll-mode
  • How is Emacs used in a professional setting?
  • Fun fact about calendar.el - Calendrical Calculations
  • GLS in 2007 about the earliest EMACS development
• Other:
  • Alternative backward-delete-word that doesn't use the kill ring
  • Rewriting dates with Emacs multiple cursors (2019)
  • Unlock the Power of the Daemon with emacsclient
• Emacs development:
  • emacs-devel:
    • MPS: which threads need to be registered and how?
    • Re: moving xwidget-webkit to WPE
    • CI testing of Emacs for Fedora - now built and tested with Koschei
    • Input method for Tifinagh (alphabet of the Berber language)
  • Improve Eshell's behavior when waiting for processes
  • Support interactive D-Bus authorization
• New packages:
  • casual-re-builder: Transient UI for RE-Builder (MELPA)
  • communinfo: Community maintained Info-url-alist (MELPA)
  • slurpbarf: Commands for slurping and barfing (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Mastodon #emacs, Hacker News, lobste.rs, programming.dev, lemmy, communick.news, 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!

Over at DyerDwelling there’s another nice example of using a transient menu to capture the keystrokes for a set of packages. This time it’s for some spelling related packages. The author couldn’t make up his mind on what keystrokes he wanted for the various commands so he decided to implement a menu instead.

If you’ve been reading Irreal lately, you know that I’m a big fan of this approach, especially as realized by Charles Chou’s Casual Suite. Nonetheless, I’m not sure that a menu is the best solution here. At least not for commands that do things like correct the last misspelling. I use commands like that constantly and want them instantly available without having to wade through a menu.

Still, we can have it both ways. There’s no reason to restrict yourself to one approach. You can have a menu as described in the DyerDwelling post and still specify keybindings for the commands you use all the time. And to be fair, you can also think of the sequence to invoke the menu and the option choice as a single, slightly longer, key sequence.

I’m again impressed at how easy it is to set up a transient menu. Take a look at the code in the DyerDwelling post to see for yourself.

GNU Emacs supports annotation for completion candidates. An annotation is a small bit of useful information shown next to a completion candidate which a package developer can use to provide additional help to the user while making a selection. e.g. while selecting a command, this is usually the keyboard shortcut.

In the following example, annotation is used to display a sample text with the candidate font-family applied. 

By default, Emacs uses completions-annotations face for the annotation. Use the following patch to skip changing the face when the annotation already has a face attached.

By default, Emacs evil-mode removes newly inserted spaces when exiting insert mode. However, some users may find this disruptive to their workflow. This is particularly true for those who edit file formats where trailing spaces are significant or who simply prefer to manage whitespace manually.

To prevent the automatic removal of trailing spaces when leaving insert mode, add the following Elisp code to the Emacs init file:

(with-eval-after-load 'evil
  (defun my-evil-disable-remove-spaces ()
    "Disable automatic removal of trailing spaces in `evil-mode'."
    (setq-local evil-maybe-remove-spaces nil))

  (add-hook 'evil-insert-state-entry-hook #'my-evil-disable-remove-spaces))

The function above sets the evil-maybe-remove-spaces variable to nil when entering insert mode, preventing the evil-maybe-remove-spaces function from deleting whitespace after leaving insert mode.

The evil-insert-state function, which Evil uses to switch to insert mode, behaves as follows:

• When entering insert mode: It sets the evil-maybe-remove-spaces variable to t.
• When exiting insert mode, it calls the evil-maybe-remove-spaces function, which removes trailing spaces if the evil-maybe-remove-spaces variable is set to t. Because the my-evil-disable-remove-spaces function above sets the evil-maybe-remove-spaces variable to nil when entering insert mode, it prevents the evil-maybe-remove-spaces function from deleting whitespace after leaving insert mode.

If you want to compare the behavior before and after the function above, use whitespace-mode. This mode visually highlights different types of whitespace characters, such as spaces, tabs, and newlines, making it easier to see the differences.

Customizing evil-mode with the simple piece of Elisp code above can prevent the automatic removal of trailing spaces when exiting insert mode. This adjustment allows for better control over whitespace in files.

I've had org-projectile in my config since the beginning, and while it's worked nicely for me in my main config it gave me some grief when I played around with elpaca the other week.¹

I tried to get the install instructions to work, but kept on getting errors when loading my config. Given that I only use it for one thing, to open the file TODO.org in the current project's root, I decided to just write a function for doing that instead.

(defun mep-projectile-open-todo ()
  "Open the project's todo file."
  (interactive)
  (if-let* ((proj-dir (projectile-project-root))
            (proj-todo-file (f-join proj-dir "TODO.org")))
      (org-open-file proj-todo-file)
    (message "Not in a project")))