Not much of a post this week (and in fact this is pretty low effort!), but here I present some fun with image generative AI!

That is all 😀

I want to start a video series where I talk one-on-one with a person about Emacs, technology in general, and whatever life issues. The idea is to connect via Jitsi, Jami, Signal, or something similar, and I will take care to record the conversation. I will then host the video on my YouTube channel and publicise it on my website. The video will not be edited unless you think it is necessary.

The format should be casual: a ~1-hour chat where we start with things that interest us and then go with the flow of the conversation. There will be jokes or lighthearted moments and we can run off on tangential points. No problem; no stress! I will be posing questions that are general and friendly in nature to keep the discussion going. What the questions are will depend on the topic we are covering. This should not be an interview or debate: just an exchange between Internet folks who have things in common.

You do not need to have a strong presence online to qualify. I am willing to talk to anyone. Of course, if you do have public pages, you are welcome to promote them in the chat and I will provide the relevant links in the description of the video.

Are you interested to talk with me? All I ask of you is that (i) you agree to show your face on camera and (ii) agree that I publish the video on my YouTube channel and website.

Contact me and we will sort out the meeting details: https://protesilaos.com/contact. Also let me know if you have any further questions.

We can do this!

Marcin Borkowski (Mbork) has a problem that many of we Org users have: He likes to use checkbox lists to organize tasks to ensure that he doesn’t forget any steps. An example that will resonate with most of us is using a checklist for things to pack for a vacation. So what’s the problem? The problem is how to reset those checkboxes to unchecked for the next time you want to use the checklist.

For a long time, he just did the obvious thing and performed a query-replace to change [x] to [ ]. The trouble with that solution is that it didn’t reset the checkbox cookies so he had to do that by hand. Since he knows a bit about Elisp, he decided to write his own solution. It turns out that Org already has a function, org-reset-checkbox-state-subtree, that almost does that. It will reset all the checkboxes in the current subtree so all Mbork needed to do was write a function to step down the subtrees and call org-reset-checkbox-state-subtree for each one.

It’s a surprising small amount of code and neatly solves the problem. As Mbork points out, there are some problems. His solution will sometimes call org-reset-checkbox-state-subtree for the same subtree more than once and it apparently can mess with header folding but most files you’re going to use his function on are probably sufficiently small that it doesn’t matter.

I’ve written a bunch of code like this. It may not be ready to ship but it solves a problem and I understand its limitations. It’s a win.

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

In this ~13-minute video I explain how to use the Denote user option denote-file-name-components-order. Then I show how to retroactively rename all the files that have the Denote file-naming scheme so that they follow the desired order. In the process, I cover the command denote-sort-dired (alias denote-dired), which helps produce a flat listing of Denote files, even if they exist in subdirectories of the denote-directory.

The code used in this video:

;; The default:
(setq denote-file-name-components-order '(identifier signature title keywords))

;; Any order will work.  Here is the one I am using for this demonstation:
(setq denote-file-name-components-order '(identifier signature keywords title))

;; And here is another:
(setq denote-file-name-components-order '(identifier keywords title signature))

;; And yet another one for the sake of completeness:
(setq denote-file-name-components-order '(title keywords signature identifier))

(defun prot/denote-rename-all-to-reorder-components ()
  "Call `denote-dired-rename-files' without any prompts.
In other words, preserve the value of each Denote file name component.

Use this command if you wish to modify the user option
`denote-file-name-components-order' and then want your existing Denote
files to retroactively follow that order."
  (interactive)
  (let ((denote-prompts nil))
    (call-interactively 'denote-dired-rename-files)))

A commonplace activity is to copy source code from a web page into an Org file. Ideally such code is kept structurally intact by wrapping it in an Org source block. This is typically done as follows:

1. Select source code text in web page.
2. Copy source code text.
3. Paste source code into Org file.
4. Annotate the pasted source code with an Org source block, specifying language. (#+BEGIN_SRC {language}, #+END_SRC)
   • Either done manually or using the command org-insert-structure-template (C-c C-,)

While the above is not complicated, it can get onerous if done frequently. Thankfully Org provides you with the means to automate this. For example with Org protocol, the above steps can be reduced to:

1. Select source code text in web page (no need to copy!).
2. Run web bookmark to capture selected text to Emacs.
3. Select source code language via mini-buffer completion in Emacs and commit capture (C-c C-c).

Interested? Read on. Some Elisp ahead, but hopefully not too challenging.

Capturing code with Org protocol

A convenient way to capture content from a web page is through Org protocol which builds on top of Org capture. Some setup is required before using it, but the effort is rewarded in saved time for a future you.

Shown below is a capture template with key name “code”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

("code"
 "Source Code (Org Protocol)"
 entry
 (file "~/org/notes.org")
 (function (lambda ()
             (string-join
              (list "* Source: %:description"
                    ":PROPERTIES:"
                    ":CREATED: %U"
                    ":END:"
                    "%:link"
                    (concat "#+BEGIN_SRC "
                            (cc-org-capture--code-choices "elisp"))
                    "%i"
                    "#+END_SRC"
                    ""
                    "%?")
              "\n")))
 :empty-lines 1)

The Elisp function cc-org-capture--code-choices will generate capture expansion markup to choose a language with mini-buffer completion. It is configured here to use “elisp” as the default language. The set of languages to choose from via completion is defined in cc-org-capture--src-languages. Both their definitions are shown below:

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

(defun cc-org-capture--code-choices (lang)
  "Create selection of programming language choices with default LANG."
  (concat
   "%^{Language|"
   lang
   "|"
   (string-join cc-org-capture--src-languages "|")
   "}"))

(defvar cc-org-capture--src-languages
  (list
   "C" "F90" "R" "awk" "clojure" "cpp" "css" "ditaa" "dot" "elisp" "eshell"
   "forth" "gnuplot" "haskell" "java" "js" "julia" "kotlin" "latex" "lisp" "lua"
   "makefile" "matlab" "max" "ocaml" "octave" "org" "perl" "plantuml"
   "processing" "python" "ruby" "sass" "scheme" "sed" "shell" "sql" "sqlite"
   "swift" "swiftui" "tcl")
  "List of supported Org capture languages.")

To exercise the capture template named “code” from your JavaScript enabled web-browser, create a bookmark with the following JavaScript code as its location. When you find code you want to capture, select the code and run this bookmark.

1
2
3
4
5

javascript:location.href='org-protocol://capture?' +
      new URLSearchParams({
            template: 'code', url: window.location.href,
            title: document.title, body: window.getSelection()});
      void(0);

Aside: if you use Emacs for macOS, you’ll want Scrim to get Org protocol to work.

Capturing source code by copying

Often it is desirable to just copy the source code (putting it in the kill-ring) and paste (or rather capture) it direct into an Org (or Markdown) file of one’s choosing. The following capture template named “cc” can accomplish this.

1
2
3
4
5
6
7

("cc"
 "Code"
 plain
 (here)
 (function cc-org-capture--code-select-body)
 :empty-lines 1
 :immediate-finish 1)

In the above template, the target (here) is used to insert the captured source code at the current point. The template type is set to plain to not give the captured source code any special treatment with respect to Org structure. The :immediate-finish key is set to non-nil to not create a separate capture window.

The “cc” template is intended to be invoked with a multiple-key sequence starting with ’c’, so the following entry in org-capture-templates is expected.

1

("c" "Code")

The work of constructing the wrapped source code (in this case, presumed to be in the kill-ring via system copy) is done in cc-org-capture--code-select-body. Its source is shown below.

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

(defun cc-org-capture--code-select-body ()
  "Body capture code in `kill-ring' head with language prompt."
  (cc-org-capture--code-body-from-kill-ring
   (cc-org-capture--code-choices "elisp")))

(defun cc-org-capture--code-body-from-kill-ring (lang)
  "Generate capture body for LANG code at head of the `kill-ring'."
  (string-join
   (list
    (cc-org-capture--src-block-begin lang)
    (if kill-ring "%c" "")
    (cc-org-capture--src-block-end))
   "\n"))

(defun cc-org-capture--src-block-begin (&optional lang mode)
  "Annotate begin of source code block for given LANG and MODE."
  (let* ((lang (if lang lang "elisp"))
         (mode (if mode mode major-mode)))
    (cond
     ((eq (derived-mode-p mode) 'org-mode) (concat "#+BEGIN_SRC" " " lang))
     ((eq (derived-mode-p mode) 'markdown-mode) (concat "```" lang))
     (t (concat "#+BEGIN_SRC" " " lang)))))

(defun cc-org-capture--src-block-end (&optional mode)
  "Annotate end of source code block for given MODE."
  (let* ((mode (if mode mode major-mode)))
    (cond
     ((eq (derived-mode-p mode) 'org-mode) "#+END_SRC")
     ((eq (derived-mode-p mode) 'markdown-mode) "```")
     (t "#+END_SRC"))))

The implementation of cc-org-capture--code-select-body will check the current major mode (major-mode) and depending if it is Org or Markdown, wrap the copied source code in the kill-ring (expanded by the term “%c”) accordingly.

The following code shows how the “cc” template can be added to org-capture-templates.

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

(add-hook
 'org-mode-hook
 (lambda ()
   (add-to-list 'org-capture-templates
                '("cc"
                  "Code"
                  plain
                  (here)
                  (function cc-org-capture--code-select-body)
                  :empty-lines 1
                  :immediate-finish 1)
                t)))

If you have C-c c bound to org-capture then you should see the “cc” template in the ’c’ sub-menu.

Caveats

If the source code to be captured contains any text that matches a capture template expansion then it will be processed, likely resulting in unintended behavior. Look out for text that starts with ’%’.

Closing Thoughts

If you’re still here thanks for your attention! This post required a fair amount of Elisp understanding, but the reward for knowing it is the ability to build very bespoke Org capture workflows. Motivated readers are encouraged to take these examples and run with them. To this end I’ve deliberately left out a capture template example of “hard-coding” a language as an exercise to the reader.

If you end up making a template that you think others would find useful, please share it!

Links

If you're on macOS and have Org protocol setup, you might be interested in this post "Capturing an Org note via macOS Shortcuts".

There's a new carnival in town, and I'm joining in. The theme for this month is "Writing Experience", and boy what an experience it is. About 80% of my daily usage of Emacs is writing, but some parts of my workflow are tedious, or worse yet completely unused, and I've had some quality of life stuff that I've been itching to implement for a while. My configuration is not particularly well formatted either. So in all, I think it's a good time to do a bit of Winter cleaning (Southern Hemisphere rules) and build a better configuration for writing specifically.

Before looking at what my config looks like currently, let's look at what I'm actually using Emacs to write, since a use case is a good place to start from. When I write in Emacs, 99.9% of the time I'm writing in org-mode (the other 0.01% of the time is in markdown-mode with Emacs Everywhere, but I won't cover that here). By my own self-reflection, this is what I mostly use Emacs for in terms of writing (and in no particular order):

• Fiction Writing:
  • Novels or Short Stories
  • Worldbuilding
• Technical Writing:
  • Essays and Mini-essays
  • Notes, and To-Dos
  • Knowledge Management
  • Literate Programming
• Blog Posts
• Tabletop RPG Rules

The requirements for these are all relatively distinct, and my flow for some is more streamlined than others. For example, I'm quite happy with my RPG rules writing setup, at least for my current project; and I'm also pretty happy with Weblorg and blog writing/publishing. I feel like my main points of contention are essay writing and personal knowledge management. So let's have a look at what I'm doing now before I start thinking how to do it better.

(defun org-mode-init ()
  "This is called through org-mode-hook, so that I don't need to add-hook 20 million times."
  ;; I want org to display pictures inline.
  (org-display-inline-images)
  ;; I don't want monospace text by default.
(variable-pitch-mode))

(add-hook 'org-mode-hook #'org-mode-init)

(setq org-log-done 'time ;; I want to keep track of the time tasks are completed.
    org-return-follows-link t ;; I want to be able to follow links easily.
    org-hide-emphasis-markers t ;; This is a big one: hide markup syntax like ** and //.
    org-pretty-entities t ;; These two variables together render latex entities as UTF8, which means that Greek letters, subscript, and superscript are all rendered correctly.
    org-pretty-entities-include-sub-superscripts t
    org-enforce-todo-dependencies t ;; Prevent changing a parent to DONE if the children aren't
    org-enforce-todo-checkbox-dependencies t
    org-agenda-skip-scheduled-if-done t ;; Don't show done stuff in the agenda view
    org-agenda-skip-deadline-if-done t
    org-agenda-skip-timestamp-if-done t
    org-todo-keywords '((sequence "TODO" "WIP" "DELEGATED" "WAITING" "|" "CANCELLED" "DONE")) ;; Some extra keywords in addition to TODO and DONE
    org-refile-targets '((org-agenda-files :maxlevel . 2)) ;; Allow any agenda files to be refile targets
    )

(setq org-cite-global-bibliography '("~/.org/global.bib") ;; Global bibliography location)

  (use-package org-modern
  :hook ((org-mode . org-modern-mode)
         (org-agenda-finalize . org-modern-agenda)))

(use-package org-modern-indent
  :straight (org-modern-indent :type git :host github :repo "jdtsmith/org-modern-indent")
  :hook ((org-mode . org-modern-indent-mode)))

(use-package wc-mode
  :hook ((org-mode . wc-mode))
  :config (setq wc-modeline-format "WC[%tw]"))

  (defun mark-whole-word ()
  "Marks the whole word underneath the cursor."
  (interactive)
  (forward-word)
  (set-mark-command nil)
  (backward-word))

(defun mark-sentence ()
  "Marks the entire sentence underneath the cursor."
  (interactive)
  (forward-sentence)
  (set-mark-command nil)
  (backward-sentence))

  (defun move-sentence-right (&optional arg)
  "Moves the whole sentence to the right of the next sentence."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-sentence)
    (backward-sentence)
    (left-char) ;; Capture previous space
    (kill-sentence)
    (forward-sentence)
    (yank)
    (backward-sentence)
    (setq arg (1- arg))))

(defun move-sentence-left (&optional arg)
  "Moves the whole sentence to the left of the previous sentence."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-sentence)
    (backward-sentence)
    (left-char) ;; Capture previous space
    (kill-sentence)
    (backward-sentence)
    (left-char) ;; Capture previous space
    (yank)
    (backward-sentence)
    (setq arg (1- arg))))

(defun move-paragraph-up (&optional arg)
  "Moves the whole paragraph above the previous paragraph."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-paragraph)
    (backward-paragraph)
    (kill-paragraph nil)
    (backward-paragraph)
    (yank)
    (backward-paragraph)
    (setq arg (1- arg))))

(defun move-paragraph-down (&optional arg)
  "Moves the whole paragraph above the previous paragraph."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-paragraph)
    (backward-paragraph)
    (kill-paragraph nil)
    (forward-paragraph)
    (yank)
    (backward-paragraph)
    (setq arg (1- arg))))

(defun break-out-sentence ()
  "Breaks a sentence out into it's own buffer for editing."
  (interactive)
  (backward-sentence)
  (kill-sentence)
  (let ((buf (generate-new-buffer "*break-out*"))
      (window (split-window-below -10)))
    (set-window-buffer window buf)
    (select-window window))
  (erase-buffer)
  (yank)
  (org-mode))

(defun break-out-choose-sentence ()
  "Chooses a sentence from the break-out buffer."
  (interactive)
  (backward-sentence)
  (kill-sentence)
  (other-window -1)
  (yank)
  (select-window (get-buffer-window "*break-out*"))
  (kill-buffer-and-window))

(use-package powerthesaurus
  :bind ("C-x t" . powerthesaurus-transient))

  (defun break-out-dwim ()
  "Either break-out or choose sentency depending on buffer name."
  (interactive)
  (if (equal (buffer-name) "*break-out*")
      (break-out-choose-sentence)
    (break-out-sentence)))

(define-key org-mode-map (kbd "C-c o b") #'break-out-dwim)

(define-key org-mode-map (kbd "C-M-<left>") #'move-sentence-left)
(define-key org-mode-map (kbd "C-M-<right>") #'move-sentence-right)
(define-key org-mode-map (kbd "C-M-<up>") #'move-paragraph-up)
(define-key org-mode-map (kbd "C-M-<down>") #'move-paragraph-down)

(define-key org-mode-map (kbd "C-@") #'mark-whole-word)
(define-key org-mode-map (kbd "M-@") #'mark-sentence)

(require 'transient)

(transient-define-prefix reorder-transient ()
  "Transient menu for text re-ordering commands."
  ["Move sentence..." ("l" "Left" move-sentence-left)
   ("r" "Right" move-sentence-right)]
  ["Move paragraph..." ("u" "Up" move-paragraph-up)
   ("d" "Down" move-paragraph-down)])

(transient-define-prefix mark-menu-transient ()
  "Transient menu for marking units of text."
  ["Mark" ("w" "Word" mark-whole-word)
   ("s" "Sentence" mark-sentence)
   ("p" "Paragraph" mark-paragraph)
   ("b" "Buffer" mark-whole-buffer)])

(define-key org-mode-map (kbd "C-c o SPC") #'mark-menu-transient)
(define-key org-mode-map (kbd "C-c o r") #'reorder-transient)

(when (and (not (equal system-type 'windows-nt)) (locate-file "harper-ls" exec-path))
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs
               '(org-mode . ("harper-ls" "--stdio"))))

  (setq-default eglot-workspace-configuration
              '(:harper-ls (:dialect "Australian")))

  (add-hook 'org-mode-hook 'eglot-ensure))

(global-set-key (kbd "M-g <left>") 'flymake-goto-prev-error)
(global-set-key (kbd "M-g <right>") 'flymake-goto-next-error)
(global-set-key (kbd "C-x M-f") 'eglot-code-actions)

(defun org-mode-company-hook ()
    "Set company backends for `org-mode' usage."
    (setq-local company-backends
            '((company-capf company-dabbrev company-files company-ispell))))
(add-hook 'org-mode-hook #'org-mode-company-hook)

.
├── lore
│   ├── raw
│   └── refined
│       ├── journal
│       └── wiki
└── tasks
    ├── maintenance
    └── projects
	└── career

(setq org-agenda-files (apply 'append (mapcar
                                 (lambda (dir)
                                   (directory-files-recursively dir org-agenda-file-regexp))
                                 '("~/.org/tasks"))))

(defun new-maintenance-file (maintenance-area)
  "Create a new maintenance file for a given `MAINTENANCE-AREA'."
  (interactive "sMaintenance area is: ")
  (find-file (concat "~/.org/tasks/maintenance/" maintenance-area ".org"))
  (insert "\n\n* Calendar\n\n* TO-DO\n\n* Routines\n\n* Archive\n")
  (goto-char (point-min)))

(defun new-project-file (project-name acceptance-criteria)
  "Create a new project file for a given `PROJECT-NAME', with some `ACCEPTANCE-CRITERIA'."
  (find-file (concat "~/.org/tasks/projects/" project-name ".org"))
  (insert (concat "\n\n* Acceptance Criteria\n\n" acceptance-criteria "\n\n* Ideas\n\n* TODO Work\n\n** Calendar\n\n** TO-DO\n\n** Routines\n\n** Archive\n"))
  (goto-char (point-min)))

(defun new-generic-project (project-name acceptance-criteria)
  "Interactive wrapper for `new-project-file', for generic projects."
  (interactive "sProject name is: \nsAcceptance criteria is: ")
  (new-project-file project-name acceptance-criteria))

(defun new-career-project (project-name acceptance-criteria)
  "Interactive wrapper for `new-project-file', for career projects."
  (interactive "sProject name is: \nsAcceptance criteria is: ")
  (new-project-file (concat "career/" project-name) acceptance-criteria))

(require 'subr-x)

(defun select-task-area (location headline)
  "Prompt for a file in ~/.org/tasks/maintenance/ to insert the capture."
  (let* ((files (directory-files (concat "~/.org/tasks/" location) t "\\.org$"))
       (choices (mapcar
                 (lambda (x) (string-remove-suffix ".org" x))
                 (mapcar #'file-name-nondirectory files)))
       (selected (completing-read "Choose a file: " choices nil t)))
  (set-buffer (org-capture-target-buffer (concat "~/.org/tasks/" location selected ".org")))
  (org-capture-put-target-region-and-position)
  (widen)
  (goto-char (point-min))
  (setq headline (org-capture-expand-headline headline))
  (re-search-forward (format org-complex-heading-regexp-format
                             (regexp-quote headline))
                     nil t)
  (forward-line 0)))


(defun select-maintenance-area (headline)
  (select-task-area "maintenance/" headline))

(defun select-project (headline)
  (select-task-area "projects/" headline))

(defun select-career-project (headline)
  (select-task-area "projects/career/" headline))

(setq org-capture-templates
      '(("i" "Idea")
      ("ii" "Generic" entry
       (file "~/.org/inbox.org")
       "* %^{TITLE} :idea: \n:Created: %T\n%?"
       :empty-lines 1)
      ("ip" "Project" entry
       (function (lambda () (select-project "Ideas")))
       "* %^{TITLE} \n:Created: %T\n%?"
       :empty-lines 1)
      ("ic" "Career" entry
       (function (lambda () (select-career-project "Ideas")))
       "* %^{TITLE} \n:Created: %T\n%?"
       :empty-lines 1)

      ("t" "Task")
      ("tt" "Generic")
      ("ttt" "Raw" entry
       (file "~/.org/inbox.org")
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} :task:\n:Created: %T\n%?"
       :empty-lines 1)
      ("ttm" "Maintenance" entry
       (function (lambda () (select-maintenance-area "TO-DO")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE}\n:Created: %T\n%?"
       :empty-lines 1)
      ("ttp" "Project" entry
       (function (lambda () (select-project "TO-DO")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE}\n:Created: %T\n%?"
       :empty-lines 1)
      ("ttc" "Career" entry
       (function (lambda () (select-career-project "TO-DO")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE}\n:Created: %T\n%?"
       :empty-lines 1)
      ("ts" "Scheduled")
      ("tss" "Raw" entry
       (file "~/.org/inbox.org")
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} :scheduled:\n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)
      ("tsm" "Maintenance" entry
       (function (lambda () (select-maintenance-area "Calendar")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} \n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)
      ("tsp" "Project" entry
       (function (lambda () (select-project "Calendar")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} \n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)
      ("tsc" "Career" entry
       (function (lambda () (select-career-project "Calendar")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} \n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)

      ("n" "Note")
      ("nn" "Raw" entry
       (file "~/.org/inbox.org")
       "* %^{TITLE} :note: \n:Created: %T\n%?"
       :empty-lines 1)
      ("nm" "Meeting")
      ("nmm" "Raw" entry
       (file "~/.org/inbox.org")
       "* %^{TITLE} :meeting: \n:Created: %T\n%?"
       :clock-in t
       :clock-resume t)
      ("nmc" "Career" entry
       (function (lambda () (select-career-project "Calendar")))
       "* %^{TITLE} \n:Created: %T\n%?"
       :empty-lines 1
       :clock-in t
       :clock-resume t)))

(defun open-inbox ()
  "Opens `~/.org/inbox.org'"
  (interactive)
  (find-file "~/.org/inbox.org"))

(defun open-maintenance ()
  "Opens `~/.org/tasks/maintenance/'"
  (interactive)
  (find-file "~/.org/tasks/maintenance/"))

(defun open-projects ()
  "Opens `~/.org/tasks/projects/'"
  (interactive)
  (find-file "~/.org/tasks/projects/"))

(defun open-career ()
  "Opens `~/.org/tasks/projects/career/'"
  (interactive)
  (find-file "~/.org/tasks/projects/career/"))

(transient-define-prefix task-management-menu ()
  "Transient menu for task management shortcuts."
  ["Go To" ("i" "Inbox" open-inbox)
   ("m" "Maintenance Directory" open-maintenance)
   ("p" "Projects Directory" open-projects)
   ("c" "Career Directory" open-career)]
  ["Create New" ("M" "Maintenance File" new-maintenance-file)
   ("P" "Project" new-generic-project)
   ("C" "Career Project" new-career-project)])

(define-key global-map (kbd "C-c o t") #'task-management-menu)  
(define-key global-map (kbd "C-c a") #'org-agenda)
(define-key global-map (kbd "C-c a") #'org-capture)

(use-package org-roam
  :straight nil
  :ensure t
  :init
  (setq org-roam-v2-ack t)
  :custom
  (org-roam-directory (file-truename "~/.org/lore/raw/"))
  (org-dailies-directory (file-truename "~/.org/refined/journal/"))
  (org-roam-file-exclude-regexp "\\.git/.*\\|logseq/.*$")
  (org-roam-completion-everywhere)
  (org-roam-capture-templates
    '(("d" "default" plain
       "%?"
       :target (file+head "${slug}.org" "#+title: ${title}\n")
       :unnarrowed t)))
  (org-roam-dailies-capture-templates
    '(("d" "default" entry
       "* %?"
       :target (file+head "%<%Y-%m-%d>.org" ;; format matches Logseq
                          "#+title: %<%Y-%m-%d>\n"))))
  :bind (("C-c n f" . org-roam-node-find)
       ("C-c n i" . org-roam-node-insert)
       :map org-roam-dailies-map
       ("Y" . org-roam-dailies-capture-yesterday)
       ("T" . org-roam-dailies-capture-tomorrow))
  :bind-keymap ("C-c n d" . org-roam-dailies-map)
  :config
  (require 'org-roam-dailies) ;; Ensure the keymap is available
  (org-roam-db-autosync-mode))

(use-package logseq-org-roam
  :straight (:host github
          :repo "sbougerel/logseq-org-roam"
          :files ("*.el")))

(defun org-roam-create-note-from-headline ()
  "Create an Org-roam note from the current headline and jump to it.

Normally, insert the headline’s title using the ’#title:’ file-level property
and delete the Org-mode headline. However, if the current headline has a
Org-mode properties drawer already, keep the headline and don’t insert
‘#+title:'. Org-roam can extract the title from both kinds of notes, but using
‘#+title:’ is a bit cleaner for a short note, which Org-roam encourages."
  (interactive)
  (let ((title (nth 4 (org-heading-components)))
        (has-properties (org-get-property-block)))
    (org-cut-subtree)
    (org-roam-find-file title nil nil 'no-confirm)
    (org-paste-subtree)
    (unless has-properties
      (kill-line)
      (while (outline-next-heading)
        (org-promote)))
    (goto-char (point-min))
    (when has-properties
      (kill-line)
      (kill-line))))

(transient-define-prefix org-roam-menu ()
  "Transient menu for task management shortcuts."
  ["Node" ("f" "Capture" org-roam-node-find)
   ("i" "Insert" org-roam-node-insert)
   ("r" "Refile" org-roam-create-node-from-headline)
   ("v" "Visit" org-roam-node-visit)   ]
  ["Dailies" ("t" "Today" org-roam-dailies-capture-today)
   ("y" "Yesterday" org-roam-dailies-capture-yesterday)
   ("n" "Tomorrow" org-roam-dailies-capture-tomorrow)]
  ["Logseq" ("R" "Fix links" logseq-org-roam)])

(define-key global-map (kbd "C-c o n") #'org-roam-menu)

(use-package biblio)

(defun bibtex-online-entry ()
  (interactive)
  (bibtex-entry "Online"))

(defun bibtex-misc-entry ()
  (interactive)
  (bibtex-entry "Misc"))

(defun bibtex-software-entry ()
  (interactive)
  (bibtex-entry "Software"))

(transient-define-prefix bibtex-transient-menu ()
  "Transient menu for task management shortcuts."
  ["Biblio" ("d" "doi.org" doi-insert-bibtex)
   ("x" "arXiv" arxiv-lookup)]
  ["Templates" ("o" "Online Resource" bibtex-online-entry)
   ("m" "Misc" bibtex-misc-entry)
   ("s" "Software" bibtex-software-entry)])

(define-key bibtex-mode-map (kbd "C-c r") #'bibtex-transient-menu)

(use-package org-roam
:straight nil
:ensure t
:init
(setq org-roam-v2-ack t)
:custom
(org-roam-directory (file-truename "~/.org/lore/"))
(org-dailies-directory (file-truename "~/.org/lore/refined/journal/"))
(org-roam-file-exclude-regexp "\\.git/.*\\|logseq/.*$")
(org-roam-completion-everywhere)
(org-roam-capture-templates
 '(("c" "Raw" plain
    "%?"
    :target (file+head "raw/${slug}.org" "#+title: ${title}\n")
    :unnarrowed t)
   ("r" "Refined")
   ("rm" "Mini-essay" plain
    "%?"
    :target (file+head "refined/wiki/${slug}.org" "#+title: ${title}\n#+author: Jakub Nowak")
    :unnarrowed t)))
(org-roam-dailies-capture-templates
 '(("d" "default" entry
    "* %?"
    :target (file+head "%<%Y-%m-%d>.org" ;; format matches Logseq
                       "#+title: %<%Y-%m-%d>\n"))))
:bind (("C-c n l" . org-roam-buffer-toggle)
       ("C-c n f" . org-roam-node-find)
       ("C-c n g" . org-roam-graph)
       ("C-c n i" . org-roam-node-insert)
       ("C-c n c" . org-roam-capture)
       :map org-roam-dailies-map
       ("Y" . org-roam-dailies-capture-yesterday)
       ("T" . org-roam-dailies-capture-tomorrow))
:bind-keymap ("C-c n d" . org-roam-dailies-map)
:config
(require 'org-roam-dailies) ;; Ensure the keymap is available
(org-roam-db-autosync-mode))

I got some time to spend with Harper, a “free English grammar checker designed to be just right,” which can be integrated into Emacs.

Before I proceed, I want to note that while the description on the website from the creator states, “you can think of it as an open-source alternative to Grammarly,” I find this to be misleading. At least on Emacs on my Mac, Harper does not compare to what I get from my premium account on Grammarly¹.

Still, if you’re looking for something free, open source, private, and fast, you should check out Harper.

To get Harper to work on a Mac, you want to install it from Homebrew, as the documentations show: brew install harper. Then for Emacs, Harper uses harper-ls, which is the Language Server Protocol server (LSP) for Harper. This is something that tripped me earlier: on Emacs, you do not interact with Harper directly, but with Emacs' built-in client for LSPs, Eglot, instead. Confused? I sure was. The part to remember is that we’re going to run M-x Eglot commands when we interact with Harper on Emacs.

A diagram would look something like this: Emacs > Eglot (LSP Client) > harper-ls (LSP Server) > Harper.

To configure Eglot to recognize and run with Harper’s LSP server, harper-ls, we can add the basic configuration to our Emacs init as described in Harper’s documentation, with a minor adjustment:

    (with-eval-after-load 'eglot
      (add-to-list 'eglot-server-programs
                   '(org-mode . ("harper-ls" "--stdio"))))

I’ve added the org-mode part instead of text-mode as described originally because I want Harper to work in org-mode. The credit for this goes to Jakub, who wrote about this in his blog and was also kind enough to email me directly and explain things even further when I was confused; so thanks Jakub! You’re alright in my book.

Jakub is from Australia, so he included a dialect option for Australian and a hook to launch eglot when org-mode is loaded, so that he wouldn’t need to launch it manually. Check his config in the link above with his explanations.

I changed my config’s dialect to American, as an option described in the documentation. After some time with Harper, I also decided to remove the org-mode hook because Harper will happily mark everything that looks like a mistake in org-mode buffers. This includes the agenda, checklists, code segments, etc.². I also prefer to separate my editing from my writing, as I find these green zigzags distracting.

When I launch Harper in org-mode with Eglot, it looks like this:

As you can see in the picture, I ran Harper on the draft of this post. It delimits every line with an issue with an exclamation point, then highlights the error with a green zigzag. When you hover over the grammatical error with the point (or the mouse cursor), Harper displays the error in the mini-buffer. In the case above, it lets me know I have a sentence that is too long.

You can correct mistakes directly with Harper by utilizing the correct Eglot commands (remember that you have to “talk” to Eglot to work with Harper). For example, you can use its Code Actions with eglot-code-actions, which will display a menu of available fixes to replace your text with. I’m quickly learning I should probably get a shortcut for this because I’m going to use this plenty. There are other aspects of Harper I’m still learning about; it comes with additional tweaks and configurations, including user dictionaries.

All in all, Harper does a decent job of catching most grammatical errors and spelling mistakes. However, I still find that I need to pass the text through Grammarly to catch some errors. For example, in this very post, the line where I wrote “It delimits every line with an issue…” was “It delimiters every line…” and Harper was okay with it. Harper also seems to miss my plural confusions, for example, “as an option described in the documentations,” is fine with Harper, but it should be “as an option described in the documentation.” Then there’s where, in my opinion, Grammarly shines next to other LLMs: style suggestions. I can ask Grammarly to make a part of the text shorter, more professional, more friendly, etc., and it will do so on the spot. Chat GPT and the like can do the same thing, but you have to do several copy-pastes to get to the same result, and even then, I find it’s not quite as polished. It’s also helpful to always have these versions in front of you so you can choose the style you want. Grammarly also highlights the errors it finds in different colors: definite issues will be in red, while suggestions for style will be in blue.

Many people don’t need this level of a “grammar nanny,” and I totally understand what Harper’s developers mean when they say Grammarly is overbearing. Add to that the fact that Grammarly sends all your private Emacs notes to the Grammarly servers, where they can do whatever they want with them, complete with the premium cost and… yeah, I totally get it. Meanwhile, Harper does most of the works, and fast, especially when compared to languageTool, which also requires you to install Java and deal with its weird updates. Oh, and those of you who use Obsidian: Harper has an official plugin, which I suspect works even better than what I wrote about here.

Give it a try, and if you’d like, let me know what you think. Meanwhile, I will see if I can make it my go-to grammar tool on my Linux Desktop.

Footnotes

¹ : I get Grammarly through work. If that weren’t the case, I’m not so sure I’d rush to pay for it myself, which comes close to $30 a month.

² : The reason Harper doesn’t know to ignore the org-mode syntax option for code (words between ~ ~) or other special characters is because org-mode is not yet officially supported. When this happens, I guess these issues will go away and I will try to launch Harper with a hook for org-mode again.

Greg Newman has another episode of Emacs Carnival going this month. This time it’s about using Emacs for writing. That’s a subject I’m very interested in so I’ve been looking forward to this episode’s contributions. The first is from Erik L. Arneson who writes about how he uses Org mode for all his writing.

Arneson says he’s written about 500,000 words with Org mode. Before Org he wrote mostly in LaTeX or plain text. Now, he writes exclusively in Org. His story is a lot like mine, A quick check with grep and wc tells me that I’ve written about 2 millions words with Org. Before that I mostly wrote with Troff so I’ve been using one markup language or another for a long time.

The important thing, as Arneson says, is that I don’t have to use Word or any of its evil siblings for my writing. That matters to me because Org generally doesn’t have an opinion unlike most “word processors” that think they know better than I do what I want to write and feel free to change my text accordingly without asking.

As Arneson notes, writing in Org mode is tremendously flexible. He—and I—use it for blog posts, reports, spreadsheets for keeping track of household expenses, letters, emails, texts, and even books. When you add in Emacs Everywhere, virtually everything I write is in Emacs.

As I’ve said before, I can no longer write comfortably in anything else. All the other apps that deal with text seem like Bizarro World where nothing works as you expect it to. What Emacs user hasn’t experienced the frustration of trying to use Emacs bindings in other applications? See what I mean about Bizarro World?

• Upcoming events (iCal file, Org):
  • Emacs.si (in person): Emacs.si meetup #7 2025 (v #živo) https://dogodki.kompot.si/events/0fb2dc00-8cea-4365-a6ca-ab1a3e76f0ee Tue Jul 8 1900 CET
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Jul 9 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu Jul 10 0000 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Jul 11 1800 Europe/Paris
  • EmacsSF (in person): coffee.el in SF https://www.meetup.com/emacs-sf/events/308773527/ Sat Jul 12 1100 America/Los_Angeles
  • M-x Research: TBA https://m-x-research.github.io/ Wed Jul 16 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
• Emacs configuration:
  • Mario Jason Braganza: Emacs Package Updation Checklist
  • The case against which-key: a polemic (Reddit)
  • Emacs keymaps can have helpful and even dynamic prompts (lemmy.ml)
  • Bare-bones Emacs starter setup (02:43)
• Emacs Lisp:
  • Using funcall and kmacro to execute keybindings
  • Running Emacs Lisp regression tests (ERT) in batch mode - get JUnit XML reports with EMACS_TEST_JUNIT_REPORT env var
  • Ep675 Golang vs Emacs Lisp Hashtable. Part 2 (01:12:40)
• Appearance:
  • Show All Faces Being Used in a Buffer (Reddit)
  • Protesilaos Stavrou: Emacs: doric-themes version 0.2.0
• Navigation:
  • repo-grep.el – One-keystroke recursive grep in Emacs for Git/SVN and multi-repo setups
  • Efficient Multi-Project Hacking in Emacs - System Crafters Live! (01:50:20)
• Dired:
  • Bulk rename files in the terminal using emacsclient + wdired
• Writing:
  • Emacs Writing Studio paperback now available (@danderzei@aus.social)
  • Ep672 Make Spell Checking in Emacs Windows Work Again, Part 2 (41:40)
  • Greg Newman: Emacs Carnival 2025-07: Writing Experience
  • Erik L. Arneson: Writing Experience (Emacs Carnival)
  • James Dyer: New Package! - Simply Annotate: A Lightweight Annotation System (Irreal)
• Org Mode:
  • Markdown to Org: Ex-NeovimConf Speaker Converts Me | Theena Kumaragurunathan (07:41)
  • Marcin Borkowski: Mass resetting Org mode checkboxes
  • (Update) org-include-inline: fix overlay visibility on initial file load (Reddit)
  • Jakub Nowak: Mixing Code Styles with org-babel
  • UOMF: Linking Headings (updated 2025-06-23)
  • 🧠 Org-Jupyter Emacs Kit (Reddit)
  • Capturing an Org note via macOS Shortcuts (Reddit)
  • [BLOG] #19 [[bbb:OrgMeetup]​] on Wed, June 11, 19:00 UTC+3
• Completion:
  • Protesilaos Stavrou: Emacs: mct version 1.1.0
• Coding:
  • Announcing Flyover - modern aesthetic overlay for flymake and flycheck (Reddit)
  • Greg Newman: TIL Speed up Magit on MacOS (Irreal)
  • :screwlisps-knowledge/tangle common lisp asdf package markdown tangling and lisp pathnames (@screwlisp@gamerplus.org)
  • eepitch-send leading to in-emacs common lisp image automata flocking (@screwlisp@gamerplus.org)
  • Ep673 Format Python JavaScript Golang HTML CSS in Emacs, and Wolfram Language auto format (43:55)
• Shells:
  • Take Two: Eshell (Reddit, Irreal)
  • Casual 2.7 adds support for Eshell (@kickingvegas@sfba.social)
• Fun:
  • What's your favorite emacs game?
• AI:
  • chatgpt-shell can now link/atttach files with M-x chatgpt-shell-insert-local-file-link (@xenodium@indieweb.social)
  • Planning sprint in Emacs with org-mode and gptel
  • Greger.el: Agentic coding in Emacs (Reddit, HN)
  • laurynas-biveinis/elisp-dev-mcp: Dev tools in Emacs MCP for agentic Elisp development with LLMs (Reddit)
  • Building personalized micro agents
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2025-07-01 / week 26
  • Christian Tietze: Emacs on Second Try (Irreal)
  • La dulce vuelta a casa (@maxxcan@mastodon.social)
• Other:
  • Emacs Widget toolkit – why not electron · Aleksandr Petrosyan (@tusharhero@mathstodon.xyz)
• Emacs development:
  • emacs-devel: Do we need safety abstractions over condition-variables? - long discussion about threads
  • Add file notification handler for Tramp's "smb" method.
  • Make elint obsolete (bug#78685)
  • Revert "New command 'mode-line-invisible-mode'"
  • Update NEWS with info about `fill-region-as-paragraph-function'
  • New command 'mode-line-invisible-mode'
  • ; * etc/NEWS: Announce check for Org in 'report-emacs-bug'.
  • VC: New incoming & outgoing diff commands (bug#62940)
• New packages:
  • ast-grep: Search code using ast-grep with completing-read interface (MELPA)
  • eca: AI pair programming via ECA (Editor Code Assistant) (MELPA)
  • flyover: Display Flycheck errors with overlays (MELPA)
  • mantra: A system for scripting and parsing activity beyond macros (MELPA)
  • mathsheet: Generate dynamic math worksheets (GNU ELPA)
  • qso: Customizable, Dynamic Amateur Radio QSO Logging (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, 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.

Opinionated changes and enhancements to the default minibuffer completion UI of Emacs:

• Live completions to update the results as you type.

• Passlist and blocklist of commands or completion categories to control whether the *Completions* buffer shows up eagerly.

• Other relevant options to control when the *Completions* are displayed.

• Per command or completion category sorting methods.

• A cleaner *Completions* buffer, optionally without a mode line.

• Commands to cycle from the minibuffer to the *Completions* and vice versa.

In essence, MCT is (i) a layer of interactivity on top of the out-of-the-box completion experience, and (ii) glue code that combines built-in functionalities to make the default completion framework work like that of more featureful third-party options.

• Package name (GNU ELPA): mct
• Official manual: https://protesilaos.com/emacs/mct
• Change log: https://protesilaos.com/emacs/mct-changelog
• Git repositories:
  • GitHub: https://github.com/protesilaos/mct
  • GitLab: https://gitlab.com/protesilaos/mct
• Video demo: https://protesilaos.com/codelog/2021-10-22-emacs-mct-demo/
• Backronym: Minibuffer Confines Transcended; Minibuffer and Completions in Tandem.

Below are the release notes.

Version 1.1.0 on 2025-07-07

This version contains several refinements to an already stable package.

Sort by command or completion category

The new user option mct-sort-by-command-or-category determines how completion candidates are sorted.

This is an alist where each element is of the form (SYMBOLS . SORT-FUNCTION).

SYMBOLS is either a symbol or a list of symbols. SYMBOLS can refer to the symbol of a function or completion category. It can also be t, which refers to the fallback value.

SORT-FUNCTION is a function that takes a list of strings and returns a list of strings, sorting them accordingly. Examples of a SORT-FUNCTION are:

• mct-sort-by-alpha
• mct-sort-by-alpha-then-by-length
• mct-sort-by-history
• mct-sort-by-directory-then-by-file

To not perform any sorting on the completion candidates that match SYMBOLS set SORT-FUNCTION to nil.

If there are conflicting configurations between a SYMBOLS function and completion category, then the function takes precedence (for example find-file is set to sort directories first whereas the file completion category is set to sort by history).

Optional indicator for completing-read-multiple

Users of Emacs prior to version 31 do not have a built-in way to inform them when they are dealing with a completing-read-multiple minibuffer prompt. Emacs 31 introduces the user option crm-prompt and its related functionality to tell the user what they need to know.

The mct-completing-read-multiple-indicator can be used in the meantime to achieve the same results. It is set to a non-nil value by default. Opt out by changing it to nil.

The *Completions* are persistent when needed

This concerns the case where a command or completion category is part of the mct-completion-passlist or when the user option mct-live-completion is set to non-nil or visible. In such cases, the completion candidates are on display and we want to keep them there while performing a dynamic completion, such as with the find-file command (“dynamic” in the sense that it returns a new list of candidates to match the current path).

Persisting the *Completions* means that as we narrow the list, we still see all the matching results.

In the past, we provided the option mct-persist-dynamic-completion though we do not need it anymore.

I was inspired to make this change in response to a question posed by Ryan Davis regarding the behaviour of mct-persist-dynamic-completion. This was done in issue 7: https://github.com/protesilaos/mct/issues/7.

Miscellaneous

• Vertical alignment of the *Completions* buffer is more precise. Thanks to Jessie Hu for the contribution in pull request 6: https://github.com/protesilaos/mct/pull/6.

• The command mct-choose-completion-exit no longer tries to expand further. In the previous implementation it would try to match the last known selection from the history when using a file prompt. For example we have this workflow:

  • In the previous prompt we type /path/to/file/ and exit.
  • Now we type /pa, the completions pop up, we select /path and invoke mct-choose-completion-exit. This wrongly expands into /path/foo/ instead of taking just /path (given that it has no further input to determine an extension of that string).

  Now the command will do the right thing based on the user’s input.

This is my contribution to month two of Greg Newman’s Emacs Carnival. The topic this month is “Writing Experience,” which is perfect, since I write in Emacs all the time. In fact, I am writing this blog post in Emacs right now!

Emacs Writing History

I do not know how long I have been writing in Emacs, but I have documents written in LaTeX from the early 2000s that were definitely written in Emacs, and I know those weren’t the first. I guess what is interesting about my writing experience in Emacs is how it has developed over the years. Where I originally wrote everything in plain text or LaTeX, over time I moved to org-mode and Markdown.

Writing LaTeX in Emacs taught me to view documents and writing the same way I view source code. Since all of my writing was in text formats, I could easily use version control software to store archives full of text. I began by using Concurrent Versions System (CVS), but eventually moved to Git. I have a few Git repositories with writing, but my biggest dates back to 2009. Those early commits are all LaTeX and plain text files.

commit c64500897e2509bc3316d252cda10a9119384933
Author: Erik L. Arneson <pXXX@XXX.XXX>
Date:   Sat Dec 5 10:51:06 2009 -0800

    Initial import of an old repository.

The oldest org-mode file in my writing repository dates to December 27th, 2010, and is titled “Beer and Pizza.” The commit message indicates that I pulled some writing over from another repository in this commit, so obviously I had been writing with org-mode for quite a while. I know, for instance, that “Beer and Pizza” was an article that I wrote for an early incarnation of Southern Oregon Magazine, and my notes are dated back to February of that year.

Org-mode Is A Life-changer

You have probably read other people’s experience with writing in org-mode in Emacs, so instead of sharing an exhausting list of all the life-changing, writing-improving things that it has brought me, here are a few bits that I really love about it.

It is fantastic at organizing writing projects. From being able to shift around headings and blocks of text, to combining to-do lists with writing projects, to being able to create macros and include different files—all of these things make org-mode perfect for working on medium and large projects. I write everything from blog posts to podcast scripts to books in org-mode, and it helps me stay organized.

I do not have to write in Word or Google Docs. The export functions in org-mode do a great job creating Word files, ODT files, HTML files, and all kinds of formats. If org-mode’s export abilities aren’t good enough, it can also interface with pandoc to cover all the other cases! This means I get to use all of my familiar tools and processes when writing, and I don’t have to worry about awful word processing software!

Everything I need to write can happen in org-mode! I have several websites that are built entirely out of org-mode. When I need to create slides for a lecture, I do it in org-mode. When I write adventures for Dungeons & Dragons, I do it in org-mode. When I need to whip up a spreadsheet to handle my household budget, I do it in org-mode. When I need to write a formal letter, I do it in org-mode. Frankly, it is so expressive and flexible, that I don’t need to use other tools for writing. It’s all Emacs and org-mode.

Emacs Can Be Distraction-Free

I have a hotkey connected to writeroom-mode, which plonks me right into a full-screen, distraction-free writing mode. Easy as pie! This means that when I really need to get down to business and get a lot of writing done, I don’t need to switch to a new app, leave my familiar tools behind, or go through any extra trouble. It’s just right here, built in.

No Going Back

I’ve been writing with Emacs for decades. It is my comfortable writing spot. I honestly cannot see myself abandoning it for another writing tool, because it works for me. I just used a couple of commands to check my three biggest writing repositories, and I have approximately 630,000 words written in org-mode between them. That’s a commitment!

I am aware that there are a lot of people out there using Emacs for writing, so I am excited to see what others share. I’m very pleased with Greg Newman’s choice for this second writing topic.

Edit: I realized that what I was calling my second biggest writing repository was actually my third biggest. I updated some numbers to reflect another 130,000 words of writing I found.

If you’re using Magit on macOS, here’s a tip that will either improve your life considerably or not affect you at all. The tip is from Greg Newman who says that it reduced his commit time from about 4 seconds to less than a second.

The secret? It turns out to be simply specifying a pointer to the git executable like this:

(use-package magit
  :bind ("C-x g" . magit-status)
  :custom
  (magit-git-executable "/opt/homebrew/bin/git"))

Of course, after the excitement dies down, you start thinking, “Wait! What? That can’t be right.” Well, what can’t be right is that it’s taking 3 seconds to find the git executable by searching the PATH variable. What is happening then?

It turns out that Apple provides a copy of git that it puts in /usr/bin/ but if you’re using Homebrew and loaded git with it, the executable lives in another place. In Newman’s case, that place is /opt/homebrew/bin/. In my case, it’s in another place but the same thing happens: there are two versions of git in your file system and unless you’ve performed surgery on your PATH variable, Emacs will probably find the older version provided by Apple.

What’s really going on here, it seems, is that without some further action on your part, Emacs—or more precisely, Magit— may be finding the older, presumably slower, version of git. You might wonder why someone would load git from Homebrew. As I recall, the version of git provided by Apple wasn’t quite working correctly and, in any event, you might want the latest version with all its improvements and bug fixes.

Regardless, if Magit seems slow you should:

1. Make sure you have the latest version of git loaded from Homebrew or elsewhere
2. Ensure that Magit finds that git either by adjusting your PATH variable or setting an explicit path as Newman does.

Installed Emacs again on Pop OS (I wiped it after my GPU issues), and now I realize I’ve had this weird issue in org-mode, where images are displayed in landscape mode. Some of my images are rotated 90 degrees in the wrong direction. Anyone familiar with this, what causes it, and how to fix it?

I’ve never updated my Emacs packages until recently, because Emacs is where all my writing happens, and so I’m justifiably paranoid.
But then some packages stopped working, due to various circumstances¹ and an update solved it.

So I’ve decided to update my packages once a quarter, so that I don’t lose days yak shaving when something goes wrong and I handle breakage on my terms and not the machine’s.

As far as package management goes, I want to keep things simple.
In fact, I still haven’t graduated to use-package or straight.el because my package needs are few and conservative². And so, while there are automatic update options out there, I’ll just stick to updating them manually, every quarter.

Ergo, this is the checklist I’ll use next time onwards …

1. Stop emacs user service, systemctl --user stop emacs
2. Backup emacs folder in ~/.config
3. Start emacs manually (not the service).
4. M-x package-refresh-contents
5. M-x package-upgrade-all
6. Problems? Quit emacs. Revert backup folder.
7. In the end, start emacs user sevice, systemctl --user start emacs

There’s an Org mode task, scheduled quarterly, so that I won’t forget.

… but won’t if one has a custom theme loaded, as far as I can tell.

I don’t particularly like dark mode. Its use seems more preference than science, so for those who like it, cheers! However, from time to time dark mode would be good. In the evening when I’m simply reading my RSS feeds in elfeed, for example.

I wanted something that would make the switch without adding much weight. Here’s the journey:

1. Looked at what Prot uses/recommends Modus Themes | Protesilaos Stavrou
2. Led me to GitHub – guidoschmidt/circadian.el: Theme-switching for Emacs based on daytime
3. That wasn’t gonna work for me. I realized I wanted this to happen in early-init.el so a package-based option wasn’t right.
4. Light DDG-ing later and I found Emacs and Dark Mode
5. That code would work but only on emacs-plus. But the system signals other apps when to switch, so emacs-mac must have something too …
6. Dug around in the docs for emacs-mac and found some breadcrumbs.
7. Which led me to Custom Emacs functions No. 4 – UI | macOS & (open-source) Software
8. Yes! Nearly there. Timu’s code is good but is customized to his use case. I want something more utilitarian.
9. Stripped out the bits that work for emacs-mac and maybe emacs-plus and rebuilt it into this with a little help from the robot:

(defvar my/light-theme 'modus-operandi-tinted
  "Theme to use when system appearance is light.")

(defvar my/dark-theme 'modus-vivendi-tinted
  "Theme to use when system appearance is dark.")

(defun my/apply-theme-based-on-appearance (&optional appearance)
  "Switch between `my/light-theme` and `my/dark-theme` based on APPEARANCE.

Handles both Emacs Plus (ns, using `appearance`) and Emacs Mac Port (mac, via `mac-application-state`)."
  (let ((mode
         (cond
          ;; Emacs Plus: appearance is passed as symbol
          ((boundp 'ns-system-appearance-change-functions) appearance)

          ;; Emacs Mac Port: detect from system plist
          ((plist-get (mac-application-state) :appearance)))))

    (pcase mode
      ((or 'light "NSAppearanceNameAqua")
       (mapc #'disable-theme custom-enabled-themes)
       (load-theme my/light-theme t))

      ((or 'dark "NSAppearanceNameDarkAqua")
       (mapc #'disable-theme custom-enabled-themes)
       (load-theme my/dark-theme t)))))

(defun my/setup-theme-switching ()
  "Set up automatic theme switching on macOS appearance change."
  (if (boundp 'ns-system-appearance-change-functions)
      ;; Emacs Plus
      (add-to-list 'ns-system-appearance-change-functions #'my/apply-theme-based-on-appearance)
    ;; Emacs Mac Port
    (progn
      (add-hook 'mac-effective-appearance-change-hook #'my/apply-theme-based-on-appearance)
      (add-hook 'after-init-hook #'my/apply-theme-based-on-appearance))))

(my/setup-theme-switching)

This seems to check all the boxes:

• appropriate for early-init.el
• doesn’t call external scripts or tools
• relies on the OS and emacs-mac and emacs-plus built-in capabilities
• it works, for me at least

Some notes:

• Because this runs in early-init.el, needs setting up with built-in themes that are available before the package system loads. Thankfully, Prot’s modus-themes are built-in now.
• Any other GUI setup stuff like initial-frame-alist, default-frame-alist and set-face-attribute needs configuring before this (I think; maybe not?).

As always, YMMV. Please play around with this and let me know how it works for you. I’m working on my LISP coding skills, so buyer beware.

James Dyer has announced a new package called Simply Annotate. It is, as the name suggests, a package to make annotations to a file with the feature that the original file is not modified. There are, of course, as Dyer says plenty of packages that do this sort of thing but he wanted a light weight package that specifically met his needs and preferences.

Dyer has a list of those preferences, which you can read at his post or you can take a look at the user manual. Regardless, it appears to have some nice features. Dyer has an animation that shows how the system works. The package is available on Melpa or directly from its GitHub page. There’s plenty of information on Dyer’s post, which appears to be essentially the same as the GitHub README.

I’ve tried very hard in the past to warm up to applications like this. After all, they make perfect sense: you can make personal notes concerning the file content without altering the file itself. I spent a certain amount of time making such notes but then never—ever—actually read them. I reluctantly concluded that such things were not for me. But they may be just right for you so you should definitely take a look.

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 0.2.0 on 2025-07-05

This version introduces several refinements to the individual themes comprising the Doric themes collection. Changes pertain to the intensity of colours in use. While each tweak is small, their cumulative effect contributes to a more consistent design.

Users who are interested in the contrast ratio values and relevant colour distance can refer to the contrasts.org file that is part of the project’s Git repository: https://github.com/protesilaos/doric-themes.

I extended support for several faces or face groups including:

• ace-window
• dictionary
• embark-keybinding
• man
• markdown-metadata-key-face
• package-mark-delete-line
• package-mark-install-line
• read-multiple-choice-face
• rcirc
• spacious-padding
• textsec-suspicious
• which-key-key-face
• woman

Some other faces that were already covered are revised in the interest of theme-wide consistency. Again, changes are subtle.

The colour of the directory icons in all-the-icons and nerd-icons packages is toned down a little bit to avoid exaggerations.

Several spacing-sensitive faces, like Org tables and code blocks, unconditionally inherit the fixed-pitch face. This means that, in principle, they are rendered in a monospaced font even when the user activates variable-pitch-mode or sets the default face to a proportionately spaced typeface. Users who need to specify the applicable font family can either use the following, mutatis mutandis, or take a look at my fontaine package:

(set-face-attribute 'default nil :family "Aporetic Sans Mono" :height 160)
(set-face-attribute 'variable-pitch nil :family "Aporetic Sans" :height 1.0)
(set-face-attribute 'fixed-pitch nil :family "Aporetic Sans Mono" :height 1.0)

Other theme packages of mine have an option for “mixed fonts” (like modus-themes-mixed-fonts), but I think I will not be providing options for the Doric themes. At least not for the time being while I explore the design space for minimalist themes.

Yes thats right, yet another annotation system!, in this case it is a lightweight annotation system for Emacs that allows you to add persistent notes to any text file without modifying the original content.

https://melpa.org/#/simply-annotate https://github.com/captainflasmr/simply-annotate

Still not convinced it is any different to any other note taking package in Emacs given that previous generic sparse description? Well I shall do my best to explain my own note taking ideas. Of course this is also just a pet project to continue to learn elisp, so there is that too :)

I developed this package to fill my own perceived gap in the existing Emacs note-taking ecosystem. Although annotate.el comes close to what I needed, I wanted a simplified version and something with a few workflow adjustments that better suit my note taking preferences. The result is a lightweight alternative that handles annotations the way I have always wanted them to work.

The main functional aspects that I felt were important to me that generally differ from other existing Emacs annotation packages are:

• Header-line status display with keybinding reminders
• Simple intuitive workflow (hopefully)
• Multiple display styles (highlight, fringe indicators, or both)
• Annotation editing via a dedicated buffer
• Lightweight (if possible <1000 lines - [UPDATE], no its not possible, lets try <2000 lines!)
• Multi-purpose key to show/edit/toggle annotations
• Dedicated annotation buffer that can pop in and out
• Quickly step through annotations with M-n and M-p
• Buffer summary of annotations in grep-mode format
• Quickly browse through all annotated files using completing-read
• Smart action command that adapts based on context
• Threading conversations for each annotation

See https://github.com/captainflasmr/simply-annotate/blob/main/docs/simply-annotate.org for the manual!

Quick Demo Video

Open this file and open the simply-annotate.el file

• highlight some regions and put in some annotation comments

• step through annotation comments

• show summary

• delete some annotations

Go to the directory level and now browse the 2 files

Whats New

<2025-07-03 Thu> 0.6.0

A little refactoring and tidying up.

<2025-06-29 Sun> 0.5.1

• Raw sexp editing: Edit annotation data structures directly as Elisp for complete control
• Advanced editing capabilities: Full access to thread metadata, status, priority, and comments

Updated Key Bindings:

• M-s e: Edit annotation as raw Elisp sexp

<2025-06-20 Fri> 0.5.0

• Threading system: Add replies to annotations for conversations
• Status management: Track progress (open, in-progress, resolved, closed)
• Priority levels: Set importance (low, normal, high, critical)
• Multi-author support: Configure team members for collaboration
• Tag system: Organize with hashtags (#review, #bug, #question)
• Org-mode export: Convert threads to structured TODO items
• Enhanced display: Thread info in headers and lists
• Author management: Flexible prompting modes and author changes

New Key Bindings:

• M-s r: Add reply to annotation
• M-s s: Set status
• M-s p: Set priority
• M-s t: Add tag
• M-s a: Change author
• M-s o: Export to org-mode

<2025-06-20 Fri> 0.0.1

• Basic annotation functionality
• Persistent storage
• Navigation commands
• Org-mode export
• Customizable highlighting

Installation

MELPA (Recommended)

(use-package simply-annotate
  :bind ("C-c A" . simply-annotate-mode))

Manual Installation

1. Download simply-annotate.el
2. Place it in your Emacs load-path
3. Add to your configuration:

(require 'simply-annotate)
(global-set-key (kbd "C-c A") simply-annotate-mode)

Quick Start

1. Open any file
2. Enable annotation mode: M-x simply-annotate-mode
3. Select/mark text and press M-s j to create your first annotation
4. Create some more annotations
5. Navigate with M-n (next) and M-p (previous)
6. Add replies: Press M-s r on any annotation to reply
7. Set status: Press M-s s to track progress (open/resolved/etc.)
8. Advanced editing: Press M-s e to edit annotation data structure directly

Usage

Enabling Annotation Mode

M-x simply-annotate-mode

Or bind to a convenient key:

(global-set-key (kbd "C-c A") 'simply-annotate-mode)

Creating Annotations

Simple

The M-s j command (simply-annotate-smart-action) is context-aware:

1. With region selected: Creates new annotation or edits existing one
2. On annotated text: Toggles annotation buffer visibility
3. With prefix (C-u M-s j): Forces edit mode on existing annotation
4. Elsewhere: Creates annotation for current line
5. Enter your annotation text in the dedicated buffer
6. Save with C-c C-c

Advanced Editing

Raw Sexp Editing

For complete control over annotation data structures:

1. Place cursor on any annotation
2. Press M-s e to open the raw sexp editor
3. Edit the Elisp data structure directly:
   • Modify thread metadata (status, priority, tags)
   • Edit comment text and timestamps
   • Add/remove/reorder comments
   • Change author information
4. Save with C-c C-c or cancel with C-c C-k

Example sexp structure:

((id . "thread-123456")
 (created . "2025-06-29T10:30:00")
 (status . "open")
 (priority . "high")
 (tags . ("bug" "critical"))
 (comments . (((author . "John Doe")
               (timestamp . "2025-06-29T10:30:00")
               (text . "Found a critical bug here")
               (type . "comment"))
              ((author . "Jane Smith")
               (timestamp . "2025-06-29T11:15:00")
               (text . "I can reproduce this issue")
               (type . "reply")))))

Threading & Collaboration

Adding Replies

1. Place cursor on any annotation
2. Press M-s r to add a reply
3. Enter your response
4. The annotation becomes a threaded conversation

Status Management

• Press M-s s to set status: open, in-progress, resolved, closed
• Press M-s p to set priority: low, normal, high, critical
• Press M-s t to add tags like #review, #bug, #question

Author Management

Configure for single-user or team workflows:

;; Single user (default behavior)
(setq simply-annotate-prompt-for-author nil)

;; Team collaboration
(setq simply-annotate-author-list '("John Doe" "Jane Smith" "Bob Wilson"))
(setq simply-annotate-prompt-for-author 'threads-only)  ; Prompt only for replies
(setq simply-annotate-remember-author-per-file t)       ; Remember per file

Available prompting modes:

• nil: Never prompt (single-user mode)
• 'first-only: Prompt once per session
• 'always: Prompt for every annotation
• 'threads-only: Prompt only for thread replies (great for reviews)

Author Commands

• M-s a: Change author of existing annotation/comment

Display Styles

Simply Annotate supports three display styles:

• Highlight: Traditional background highlighting (default)
• Fringe: Shows indicators in the left fringe
• Both: Combines highlighting with fringe indicators

Change styles with M-s ] or customize simply-annotate-display-style.

Viewing Annotations

When simply-annotate-mode is active:

• Annotated text is displayed according to your chosen style
• The header line shows annotation count, status info, and available commands
• * Thread info*: Header shows [OPEN/HIGH:3] for status, priority, and comment count
• Moving to annotated text shows annotation details in the header
• Press M-s j on annotated text to view/edit in detail

Navigation

Managing Annotations

Creating

• Select/mark some text
• Press M-s j to open the annotation buffer
• Make your changes
• Save with C-c C-c

Editing

Standard Editing:

• Place cursor on annotated text
• Press C-u M-s j to open the annotation buffer
• Make your changes
• Save with C-c C-c

Advanced Sexp Editing:

• Place cursor on annotated text
• Press M-s e to open the raw sexp editor
• Edit the complete data structure
• Save with C-c C-c or cancel with C-c C-k

Deleting

• Place cursor on annotated text
• Press M-s - to remove the annotation

Listing All Annotations

• Press M-s l to open a grep-mode buffer showing all annotations in the current file
• Enhanced display: Shows thread status, priority, comment counts, and author info
• Click on line numbers, press Enter or n/p keys to jump directly to annotations
• Perfect for getting an overview of all your notes and their status

Cross-file Overview

• Press M-s 0 to browse annotations across all files
• Select a file from the completion list
• Statistics: Shows annotation counts and status summaries per file
• View all annotations for that file in grep-mode format
• Source file is presented along with grep-mode list of annotations

Org-mode Integration

Export your annotation threads to org-mode files for further processing:

• Press M-s o to export current buffer annotations to an org file
• Each thread becomes a TODO item with proper metadata
• Replies become sub-entries
• Status, priority, tags, and timestamps are preserved

Tips and Tricks

Workflow Suggestions

Enable the mode globally if you wish for all files!

(use-package simply-annotate
  :hook
  (find-file-hook . simply-annotate-mode)
  :bind
  ("C-c A" . simply-annotate-mode)
  ("C-c 0" . simply-annotate-show-all))

Smart Action Usage Patterns

• Quick annotation: No selection, M-s j to annotate current line
• Edit existing: C-u M-s j on annotated text to force edit mode
• Toggle view: M-s j on annotated text to show/hide annotation buffer
• Region annotation: Select text, M-s j to create detailed annotation

Advanced Editing Tips

• Bulk operations: Use M-s e to edit multiple comments at once in sexp mode
• Data migration: Copy annotation structures between files using sexp editing
• Precision control: Manually adjust timestamps, IDs, or metadata via sexp editing
• Complex threading: Create sophisticated reply structures that aren’t possible through the UI

Display Style Tips

• Use fringe mode for code files to minimize visual distraction
• Use highlight mode for documents where you want emphasis
• Use both mode for critical files requiring maximum attention
• Change styles on-the-fly with M-s ] based on current task

Performance Notes

• Annotations are loaded on-demand per buffer
• Large numbers of annotations (100+) may slightly impact performance
• Fringe mode generally has better performance than highlight mode
• Threading: Complex threads (10+ replies) may slow annotation buffer rendering
• Sexp editing: Large annotation structures may take a moment to format and parse

Over at the Emacs subreddit, SecretTraining4082 asks long term vanilla Emacs users how their hands are holding up. You’d be forgiven if you think the answer is “terrible”. After all, it’s received wisdom that Emacs’ default key bindings are particularly hard on your hands and inevitably lead to Emacs pinkie or some other form of RSI. Certainly there are serious and well informed people like Eric Fraga who say that RSI caused them to move to Evil mode.

I’ve always taken these people at their word, of course, but, even more, have generalized their experience to the larger Emacs user population, even though I have never suffered from any RSI problems despite years of Emacs use and even more years of constant keyboard use.

I was, therefore, a bit surprised at the answers to SecretTraining4082’s question. Almost every responder said that they didn’t suffer any significant RSI problems despite years of vanilla Emacs use. Many of them attributed this to turning the Caps Lock key into another Ctrl key. I’ve been doing this for as long as I can remember—long before I was an Emacs user—so perhaps that helps explain my lack of RSI problems.

Some of the commenters recommended the usual things like split/ergonomic keyboards but it’s surprising how many said they have been using vanilla Emacs for 30 or 40 years without any problems and without doing anything special other than making Caps Lock into another Ctrl key.

There are, for sure, people who do suffer RSI problems from the default Emacs keybindings but I was surprised at the number of people who said they didn’t. It appears that the idea that Emacs keybindings inevitably lead to RSI may be another trope used by Emacs haters to justify their animus.

Discovered Harper in this blog post but not sure how to get it to work. Installed with homebrew, evaluated the default lisp they have on their site and… ok, now what? I don’t see any Harper-related commands. Has anyone figured it out?

Short version: Harper is a frontend to Server Language Protocol (SLP). Emacs has a built-in SLP called Eglot. This means you use Eglot on Emacs to run Harper, so the interactive (M-x) command is Eglot (and it helps if you spell it correctly 🤦‍♂️). The E-Lisp configuration they have on their website (above) works fine, provided Eglot is configured to run and you have Harper installed.

I will expand later after I experiment some more.

After yesterdays post about Charles Choi’s second take on Eshell, I discovered that Choi’s post was part of a collection by Christian Tietze on a second take on various Emacs topics. Tietze himself had a post on Emacs on Second Try.

His story is not at all like mine. He first use of Emacs was under duress as part of a university course. He used it because it was required but left it behind as soon as he could. He was pretty happy using it with the text based terminals at school but once he got his first Mac he abandoned it completely.

Over the years, he learned about things like the package system and compiling from within Emacs. He was also attracted to the configurability of Emacs. He liked some of the Xah Lee’s bindings and was able to incorporate them into his Emacs configuration.

Eventually, of course, Tietze became a convert. His story and mine are alike in one respect: we both initially resisted Emacs and spent some time overcoming that resistance. And, of course, we both became committed Emacs users.

It is, really, a common story. Many of today’s zealous Emacs users took some time to adopt it. For some, like me, it took several tries before it took.

I've been using Magit in Emacs for many years and on larger (and some smaller) projects there would usually be a 3 to 5 second delay with magit-status and commits. Today I've been refactoring my config and fixing annoyances and learned that setting the git executable explicitly fixed that issue for me - from about 4 seconds down to less than a second.

(use-package magit
  :bind ("C-x g" . magit-status)
  :custom
  (magit-git-executable "/opt/homebrew/bin/git"))

With a new update of Scrim v1.1.0 on the App Store, it seems an opportune time to show a nice macOS Shortcut integration with it.

The use case is this: You're on your Mac, working on something else other than Emacs (it happens!) and you want to make a quick note in an Org file without having to context switch to Emacs.

You can accomplish this with a macOS Shortcut. Shortcuts is an Apple tool that lets you orchestrate different apps to achieve a custom workflow.

Shown below is the shortcut named “Make Note Entry” to accomplish the above use case. It will:

1. Prompt the user to enter text.
2. Run a Python script on that text and construct an Org protocol capture request with it using the template named "note".
3. Issue (open) the Org protocol request.

If the shortcut is configured so that “Pin in Menu Bar” is turned on, you will see some variant of its entry in the Shortcuts bar icon menu.

Running the shortcut “Make Note Entry” will prompt you with a dialog where you can enter your note:

Pressing the “Done” button will result in the entry being inserted at the top of the file “~/org/notes.org” as shown below. Note however that Emacs is not raised with this shortcut. The screenshot below is only shown to illustrate that the entry is there.

Installation

Want to try this out? Here’s what to do:

1. Understand Org protocol

If you don’t already then read up about it at org-protocol.el – Trigger actions in Emacs via a custom URL scheme.

2. Have Scrim installed and configured

Learn more about Scrim at http://yummymelon.com/scrim.

3. Add the capture template “note”

On the Emacs side, add the following template entry to org-capture-templates. This template named “note” defines an entry with a heading that has an inactive Org timestamp (“%U”) and the body containing the entered text (“%i”). The destination of this note entry is in the file “~/org/notes.org”

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

("note"
 "Note (Org Protocol)"
 entry
 (file "~/org/notes.org")
 (function (lambda ()
             (string-join
              '("* %U"
                "%i")
              "\n")))
 :prepend t
 :immediate-finish t
 :empty-lines-after 1)

Observe that this template uses the keys :immediate-finish to not make the entry interactive and :prepend to insert the entry at the top of the file.

4. Add the Shortcut “Make Note Entry”

Download the shortcut file Make Note Entry.shortcut and double-click on it to install. It should now be in your Shortcuts collection.

5. Run “Make Note Entry”

On the first run of this shortcut, you will be prompted twice to give it permissions: 1) to run the shortcut and 2) to open Scrim. Inspect that its contents correspond with its screenshot above and grant them.

Closing Thoughts

Readers are invited to take these ideas and customize them for their own purposes.

If you’re a regular Irreal reader, you’ll be familiar with Charles Choi. He often has useful takes on Emacs matters and, of course, he’s the author of the excellent Casual Suite that helps you use all the arcane features of many familiar Emacs commands.

Early on in his Emacs career, Choi tried Eshell but it didn’t take. That’s because, he says, he was expecting it to act like a normal shell, which it most certainly doesn’t. Now Choi has a post that offers a second take on Eshell. It’s a take informed by Choi’s many years of using Emacs and learning to appreciate Eshell.

Choi says that you should begin by thinking of Eshell as offering an Emacs REPL that can easily reference the command line utilities traditionally accessed through a conventional shell. He gives several examples of how that works.

He also mentions something that I’ve noticed too. He now does most of the things he used to do in a conventional shell through Emacs functionality like Dired and Magit. He has a table in his post that compares various shell tasks with their corresponding Eshell equivalents.

I try to use Eshell whenever I need a shell but I haven’t internalized the Eshell way as Choi has. Reading his post has inspired me to do better and try to use Eshell more often. One way to do that is to use Eshell instead of using a key shortcut or Meta+x to invoke Emacs functions such as Dired.

If you’d like to improve your Emacs game, take a look at Choi’s post. There’s a lot of meat in it.

In 2018, Sascha Fast of zettelkasten.de was on a minimalist task management journey and dug into Emacs org-mode, and pressured me for days (we were sharing an apartment back then) to give it a shot, because it surely would be my jam.

While I knew Emacs existed, I didn’t feel compelled to even try it.

I did use Emacs as part of a compulsory University course on UNIX and terminal program basics. We went through the Emacs tutorial on our own terms there. I picked up a couple of shortcuts that turned out to be available system-wide on Macs, too, like Ctrl-D to delete forward, for example, and I used that a lot on laptop keyboards that only come with a dedicated backspace key. But using Emacs for anything outside that course didn’t feel too appealing. I did use it for assignments, because I liked it somewhat better than the other options for text editing on our computer terminals at Uni.

Still, I was very happy with TextMate and other “Mac-assed Mac apps”, so I didn’t bother using the software we had to use from our University terminals for more than absolutely necessary, even though it was fun to hack around in such a bare-bones environment. – Oh, if only I knew how not-bare-bones Emacs in particular was! Nobody told me about the package system at University! For example, I used Emacs to edit source files, then Ctrl-Z to move it to the background, compile from the shell, then move Emacs to the front again. I could’ve done all of this and more from within Emacs, and I didn’t know. So that was my first Emacs experience as a terminal-based text editor that had some weird but learn-able text editing shortcuts. (If only I knew …)

When I got my first Mac, I already had a laundry list of must-have apps. That was in 2008. And during that time, OmniFocus came out (work-in-progress page from 2007), and I just needed to have that app. I used it as my project and task management tool for years, with short stints into trying out Things actu. So in 2018, I had all my stuff in OmniFocus: private tasks, programming projects everything. I didn’t want to switch. It took Sascha a lot of convincing until I caved because of that. But I gave it a try eventually the more features and tweaks and packages he brought up. A digital nerd cave was promised, and boy did it deliver.

I found Emacs Lisp weird, but the malleability of the system sounded just too appealing. I was amazed that plain text UI’s could be ab-used to render so many details. Eventually, I managed to make Emacs look okay (I’m a software developer, so my standards for ‘okay’ are quite low to be productive). It eventually didn’t feel like a downgrade. OmniFocus handled copy-pasting of images and other files as task attachments nicely, and org-mode …. well, I gave up on using attachments and inline images/screenshots as much early on to focus on other things, and 7 years later still haven’t bothered to look into this for most of my .org files.

What I did adopt early on was a modal key binding by Xah Lee. All web searches for Emacs Lisp tips went to his site (or Sacha Chua’s), and Xah clearly is into ergonomics, so I gave it a shot and loved it.

Especially the B key in command mode, bound to xah-toggle-letter-case. It cycles the region or the word next to the point between capitalizing the first letter, lowercase, and all caps. I used this a lot when proof-reading and editing book manuscripts and blog posts in our collaboration at zettelkasten.de. Really, it’s not funny how often I pressed this key.

The Xah Fly Keys command mode (aka default/non-insert mode) also comes with very nice text movement keys without having to press any modifiers. It’s easier to visualize when you check out the key binding graphic:

You end up with arrow keys on I, J, K, L, on QWERTY. And then above the left arrow (J) and the right arrow (L), you have U and O bound to move by word boundary backward and forward, respectively. And to the outside, left and right of J and L, you have H and : to move to beginning and end of line, respectively.

It’s like an arrow key cluster, but enlarged.

When proof-reading, this and the case toggle key binding did a lot of the heavy lifting. It’s much nicer to have all the movement keys next to the right-hand home row than having to hold the Opt key and use arrow keys to move by word boundary on Mac. Much, much nicer.

This sold me to the idea that if I’m spending such an ungodly amount of time in a text editor anyway, I should be able to do these kinds of customizations to make it fit my work.

Eventually, I uninstalled TextMate (after more than a decade of use) and OmniFocus.

When I did, I also went down other rabbit holes to move email, version control, shell interaction, … into Emacs. Because I could, so why wouldn’t I …?

Hire me for freelance macOS/iOS work and consulting.

Buy my apps.

Receive new posts via email.

To kickstart the Emacs Carnival, and as a hat tip to our recent inspiration, this month’s topic is borrowed from the June IndieWeb Blog Carnival: the topic is “Take Two”, hosted by Nick Simon:

Ever wish for a do-over? “Take two!” (or three, four, etc.) might be shouted by a film director or audio engineer looking to get a somewhat different outcome from a group of actors or musical performers. Would you like a second shot at something that didn’t land?

This is a perfect fit for Emacs users:

We usually don’t nail “it” on our first try – init.el bancruptcy; refactoring hacky Emacs Lisp code; leaving Emacs only to come back englightened much later; running two Emacsens in parallel. There are plenty of possible second takes when it comes to Emacs!

So for this month, our first community blog carnival, I want you to:

• meditate on “Emacs” and “take two”,
• blog about it,
• then send me a link to your blog post.

That’s it! I’ll aggregate submissions for all of June in this post.

Don’t have a blog, yet?

Well, just start one already! :)

It’s the future of the internet!

What’s a Blog Carnival, Again?

This is our first Emacs Carnival, so you may not know the format. 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!

Thanks to Sacha Chua for her post “Working on the plumbing of a small web community” that was part of the May 2025 IndieWeb Carnival, and got me thinking why there’s no Emacs Carnival, yet, and for her encouragement to kickstart this.

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, July 1st (Central European Time), so that every time zone has had a chance to meet the June 30th deadline :)

Bonus: Submit your indie blog post to Nick as well (he really said so)!

These have been submitted as of 2025-06-30:

1. Kemal: Announcing Brainiac Project
2. Jeremy Friesen: “Take Two”
3. Carlos Pajuelo Rojo: “Take two on Emacs (Toma dos de Emacs)”
4. Mike Hostetler: Emacs: Take 2
5. Sacha Chua: Thinking about time travel with the Emacs text editor, Org Mode, and backups
6. Shom: Undo finally clicked with vundo
7. Eugene Andrienko: My Emacs configuration (common parts)
8. Ross A. Baker: Take Two: Coming Home to Emacs
9. Greg Newman: Emacs Take Two (Eglot)
10. Charles Choi: Take Two: Eshell
11. Dibyashanu Pati: Take Two - A new Start
12. Rodion Goritskov: Take two to blogging with Emacs
13. My own post, Emacs on Second Try

Thanks everyone for participating! July is being hosted by Greg Newman: Writing Experience. You can also host of a future carnival yourself, don’t be shy :)

Hire me for freelance macOS/iOS work and consulting.

Buy my apps.

Receive new posts via email.

I've really started making good use of org-babel recently as part of my job, and org-babel-tangle has been particularly invaluable. I never honestly expected to get any use out of org-babel outside of taking lecture notes or working through textbooks. Don't get me wrong, it's a very useful tool - and I want to explain how I'm using it now that I've found a really solid use-case for it.

If you're unfamiliar, org-babel is a literate programming extension for org-mode. On a surface level, it works similar to a Python notebook. It allows you to specify what major mode to treat a code block as and execute code directly from within your org-mode file. It also allows you to rip code out of code-blocks and place it into another file. So, for example, I can have two code-blocks at different points in my org file, both with a :tangle file.cpp header, and have them both be inserted (in order) into file.cpp. This feature is often used for literate configs within Emacs - where one org file contains all the configuration code, with suitable annotations.

I don't use a literate config (currently). Actually, when it comes to Lisp I'm generally against being too literate in your code, either in code comments or literal literate programming. There's a quote out of Riastradh's Lisp Style Rules that I generally adhere to:

Write comments only where the code is incapable of explaining itself. Prefer self-explanatory code over explanatory comments. Avoid `literate programming' like the plague.

Rationale: If the code is often incapable of explaining itself, then perhaps it should be written in a more expressive language. This may mean using a different programming language altogether, or, since we are talking about Lisp, it may mean simply building a combinator language or a macro language for the purpose. `Literate programming' is the logical conclusion of languages incapable of explaining themselves; it is a direct concession of the inexpressiveness of the computer language implementing the program, to the extent that the only way a human can understand the program is by having it rewritten in a human language.

In Lisp, via macros, we usually have the luxury of completely changing the "language" (not literally) of the code we write, which means that code can, in my opinion, actually be self-documenting. Whenever I feel the impulse to annotate something with a comment, I try to take time to reflect on whether that line could instead be written in a better way that requires less external explanation. There are exceptions, like marking where a section of some logic begins and ends, but that's my general philosophy. It's also why I like Racket so much - being able to switch as required between effectively any syntax you want for a particular problem is very useful for maintaining readability in my opinion. Or just because I want to write something using APL syntax.

However, at work, I don't have the luxury of writing in Lisp. Currently I'm doing data engineering with dbt, and I'm mostly writing in SQL (with Jinja macros sprinkled on top). There's also been a lot of hubbub around code style recently, for a number of reasons I won't get into, and now we are recommended to use sqlfluff to fix up formatting on SQL files. So, my two issues here are:

1. SQL can be very opaque without sufficient commentary (something that is very true for a lot of older dbt models in this codebase).
2. I do not like the standard sqlfluff formatting rules. This is really just a personal grip, but having functions and keywords be CAPITALISED has always seemed a bit pointless to me, as though it's a relic from a time before syntax highlighting.
3. Bonus: dbt tests are often undocumented and (this is a problem with a lot of test suites, not just dbt) are abstracted away from the context of the code they're testing.

org-babel helps me fix all of these issues in one fell swoop. Better yet, it lets me do so without ever bothering other people working in the repository with org-mode or Emacs.

Let's tackle the first issue: opaqueness and literate programming. There is more to this than just explaining that "Oh, line X does Y and Z". The business context of a particular decision can also be very helpful to keep track of, and so is the story or task in Jira that a model or code block is a part of. While the former of these two could be done with just code comments, the latter benefits greatly from org's structural editing. For example, if a bunch of user stories are related and should be (per the system design) in one folder in the tree, we can structure the file like so (DE- is the user story prefix in Jira):

* DE-1: Building some pipeline
** Model 1
** Model 2

Even better, some models are made up of a massive chain of SQL CTEs. We can add those to our structure too:

* DE-1: Building some pipeline
** Model 1
*** CTE 1
*** CTE 2

For each model, we can specify the file we want the model to untangle to via header properties for each code-block.

* DE-1: Building some pipeline
** Model 1
:PROPERTIES:
:header-args:sql: :tangle model_1.sql :comments no :padline no
:header-args:yaml: :tangle _model_1.yml :comments no :padline no
:END:

*** CTE 1
*** CTE 2

This way, every SQL code-block within Model 1 automatically gets tangled into the right file, and the YAML (which is used for test specification in dbt) goes to its own file. I can write as much as I want around a code block, and it will also be ignored during the tangle. But, if I want a specific piece of text to be inserted as a comment in the output file (which I might want to do, since the output is going into version control and no one but me will ever see the 'master file'), I can do that by adding :comments org to the header of the code-block.

OK, so literate programming is solved. Let's look at the bonus issue next since that's still more in the realm of literate programming as a whole. One benefit of this setup is that I can write my YAML tests directly next to the actual SQL source code. For example:

#+begin_src sql
  select something from somewhere
#+end_src

:testing:
This goes to the yaml.
#+begin_src yaml
  - name: some_column
    data_Type: INTEGER
    tests:
      - not_null
#+end_src
:end:

This of course requires setting up the boilerplate for the YAML file, which I do in a separate code-block before the first CTE section. I also use this preface to specify the dbt materialization and table alias, as well as add a general comment as to the purpose of the model.

If you're familiar with YAML, you will know that indentation is used to determine scope, and tangling org files tends to mess up the whitespace rules. The solution here is to set the org-src-preserve-indentation variable to t - but we want this to be on a per-file basis. And we have some other Elisp that we want to run, so that we can fix the second issue of code style. I have an Elisp code block that looks like this at the start of the org file:

#+name: startup
#+begin_src elisp :results silent
  (setq org-src-preserve-identation t)

  (defun sql-format ()
    "Run sqlfluff on the current file."
    (call-process-shell-command (concat "sqlfluff fix --dialect snowflake" buffer-file-name)
                            nil
                            nil))

  (add-hook 'org-babel-post-tangle-hook (lambda () (when (string-match-p ".sql\\" (buffer-file-name))
                                                   (beginning-of-buffer)
                                                   (flush-lines "-- :end:")
                                           (flush-lines "^$")
                                           (save-buffer)
                                           (sql-format))))
#+end_src

The sql-format function just runs sqlfluff over the file of the current buffer, our team is using Snowflake so that's the dialect I've selected. I want a hook to run this function on the output whenever I tangle an SQL file, so that's what the add-hook block is doing. The reason for the two flush-lines calls is to get rid of any :end: comments (which come up when I want a comment after a :testing: section) and to remove any empty lines (since sqlfluff will handle padding on it's own). This means that I can write the SQL however I like, and then not care about formatting the output. In fact, until I send the PR for review, I never even have to read the actual output of the master file. I can just work in it the whole time.

We can run this code-block from within org-mode with C-c C-c, but it's a bit of a chore to do this each time I enter the file. There is a better way: with local variables I can execute this code-block when I enter the file. This is also the reason for #+name: startup at the top:

# Local Variables:
# org-confirm-babel-evaluate: nil
# eval: (progn (org-babel-goto-named-src-block "startup") (org-babel-execute-src-block))
# End:

Chuck this at the end of the org file, and now every time you open it that startup block will run.

That's basically it. There's a few caveats: obviously, once this gets merged into the version control then any changes won't synchronise with the org file. This could be fixed with link comments and org-babel-detangle, but that goes against the making sure no one else in the team ever needs to interact with org. This workflow is supposed to be for myself only, and not interrupt anyone else in their reading or writing of the code. This does mean that once it starts going through review, and especially once any code is actually merged, the master file is essentially useless as it won't stay up to date. But that's OK, because usually any changes that are made after merge are minor, and I can still keep the org file updated with any information that shouldn't be a file comment. Or, I can export the whole thing as a word document to describe the implementation in plain English to the reviewer. Not sure if that will ever come up, but it's nice to have the option.

There are many, many posts on Irreal about the journey that people make from the hinterlands to Emacs. This post is about the journey from uber-distributions like Spacemacs and Doom to plain old vanilla Emacs. Irreal doesn’t hold any position, political or otherwise, on what distribution you should use. We’re content to let each user find his or her own Nirvana.

Still, it’s true that many converts come first to Doom or Spacemacs because they find it a bit more familiar and comfortable. Plenty of those people find a permanent home in one of those distributions and live happily ever after. Others, though, still hear the siren song of traditional Emacs and eventually complete their journey by adopting vanilla Emacs.

Donovan Ratefison has a post that recounts his own journey. He has a nice metaphor involving drinking tea. When he first started drinking tea he liked it with lots of sugar. Eventually he discovered that the sugar was masking the true taste and aroma of the tea. The raw tea was, perhaps, an acquired taste but once acquired it opened up a whole new world or tastes and sensations to him.

So it was with Emacs. Ratefison tried both Spacemacs and Doom and liked them both but vanilla Emacs kept calling to him. He like may others decided that he wanted a minimal configuration where he understood everything and there were no packages that he didn’t actually need and use.

He includes a copy of his init.el and it is, indeed, simple. He loads only a few packages. He will probably find the need for additional packages as his Emacs use matures. That, at least, has been my experience but it seems that he has found, as with tea, that unsweetened Emacs is better.

Update [2025-07-07 Mon 18:55]: Added link to Ratefison’s post. Thanks—again—to Sacha.

Plan 9 is an Operating System (OS) from Bell Labs which is a successor to UNIX. It builds on the learnings from the previous Operating systems. Network computing and graphics is an integral part of the OS rather than an afterthought. It is modular and portable - it comes with a cross compiler. It is available, under MIT License, which anybody can use, learn and tweak.

Features

• Everything is a file.
• Singular Grid: All the computers running Plan 9 OS and connected together act like a singular grid. So there's no need for remote access solutions like VNC or RDP. This cool video shows a small glimpse of the possibilities.
• Process Isolation: Processes run within their own namespaces and are isolated from each other. So you can run rio (the window manager) within rio. Applications like Browsers don't need complicated sandboxing. And a crashing program is unlikely to bring down the OS.
• No DLL Hell: Binaries are always statically linked. So there's no DLL hell and there's no need for application bundles like Snap, Flatpak and Appimage.
• Plumber: This allows user to define custom rules for disparate application interactions. e.g. opening a browser for HTTP URL or a mail client for mailto URL or a text editor for a file URL.
• Rune: Unicode (UTF) character handling (multi-lingual support) is easily done via Rune API.

Plan 9 Keybindings

Plan 9 OS user interface (UI) is mouse oriented. However, thanks to Common User Access (CUA) specification, we have come to expect keyboard shortcuts to work for certain repeated actions. e.g. Ctrl+x, Ctrl+c and Ctrl+v for cut, copy and paste respectively. This is an attempt to introduce the same in Plan 9.

Code (Work in Progress)

• https://gitlab.com/atamariya/plan9front/-/blob/dev/sys/src/cmd/rio/dat.h
• https://gitlab.com/atamariya/plan9front/-/blob/dev/sys/src/cmd/rio/rio.c
• https://gitlab.com/atamariya/plan9front/-/blob/dev/sys/src/cmd/rio/ui1.c
• https://gitlab.com/atamariya/plan9front/-/blob/dev/sys/src/cmd/rio/wind.c 

Plumber

Running rules are in /mnt/plumb/rules. For permanent changes, modify /sys/lib/plumb/basic.

Some useful plumbing rules: treason (video)

References

• Call for Proposals open for EmacsConf 2025 (Reddit, lobste.rs)
• Emacs Carvival writing themes:
  • July: Writing Experience
  • June round-up: Take Two
• Upcoming events (iCal file, Org):
  • Emacs Paris: S: Emacs workshop in Paris (online) https://emacs-doctor.com/ Tue Jul 1 0830 America/Vancouver - 1030 America/Chicago - 1130 America/Toronto - 1530 Etc/GMT - 1730 Europe/Berlin - 2100 Asia/Kolkata - 2330 Asia/Singapore
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/307923518/ Wed Jul 2 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Thu Jul 3 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Fri Jul 4 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • Emacs.si (in person): Emacs.si meetup #7 2025 (v #živo) https://dogodki.kompot.si/events/0fb2dc00-8cea-4365-a6ca-ab1a3e76f0ee Tue Jul 8 1900 CET
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Jul 9 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu Jul 10 0000 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Jul 11 1800 Europe/Paris
• Beginner:
  • Dark mode Emacs Reference Card (@dennyhenke@social.coop)
• Emacs configuration:
  • My Emacs configuration (common parts) | Dragon’s notes (@evgandr@mas.to)
  • I just released my first package: Kakit - Kakoune/Helix like modal editing in Emacs
• Emacs Lisp:
  • Emacs Package Development: The Emacs Reader (VI: v0.3.0 release and further triaging) - 6/29/2025, 2:55:40 PM - Dyne.org TV
  • Marcin Borkowski: Interacting with an external process via stdin and stdout
  • Xah Talk Show Ep669 emacs lisp and random (50:15)
• Appearance:
  • Rahul Juliato: Setting up Emacs native tab-bar and tab-bar-groups for a tmux-like experience (Reddit)
  • vim-tab-bar.el: Make the Emacs tab-bar Look Like Vim’s Tab Bar (Release: 1.0.8) (Reddit)
  • I created a set of macOS 26 "Liquid Glass" app icons for Emacs (Reddit)
• Navigation:
  • Searching and Editing in Buffers with Occur Mode - Mastering Emacs (@ljwrites@rage.love)
  • Amit Patel: Emacs: marking text
  • Protesilaos Stavrou: Emacs: beframe version 1.4.0
  • Fold and Focus — Focused navigation in Org, Markdown, and Elisp (Emacs package) — Listful Andrew (Irreal)
    • Focused navigation in Markdown — Listful Andrew
• TRAMP:
  • Making TRAMP go Brrrr (Reddit, lobste.rs, Irreal)
• Writing:
  • #EXTENDEDCUT damaru+doug merritt on #emacs, #meditation, edrx's #eev #lispygopherclimate - Community Video (@screwlisp@gamerplus.org)
  • My 2025 Note-taking workflow | Donovan R.
  • Jakub Nowak: Goodbye LanguageTool, Hello Harper
• Org Mode:
  • Emacs Org Mode Date Range Calculated 2025_06_26_08:31:09 - YouTube (@unixbhaskar@mastodon.social)
  • How I Use Org Mode Part One · 🌀 bledleys blog (@bledley@mastodon.social)
  • Guix and Org mode tutorial (@civodul@toot.aquilenet.fr)
  • Using Emacs Org-Babel instead of Jupyter(Lab) Notebooks (32:57)
  • Built a simple Emacs package to sync Quip docs with Org-mode - looking for feedback!
  • Emacs org mode changelog for your github repositories (37:36)
  • Worg Org protocol page updated for 2025 (Reddit)
  • orgfetcher: Use Python to fetch data from any external source and track it in an Org file
  • Show HN: Ten Dollar Adventure, an interactive kids' book on entrepreneurship | Hacker News - Org Mode to Twinery (interactive fiction) and back again
• Completion:
  • pulu/tidal-completion.el: TidalCycles completion for Emacs - Codeberg.org (@ahihi@anticapitalist.party)
• Coding:
  • Powershell script to Update Tree Sitter langs to latest , for emacs on Windows
  • James Dyer: Setting up a C# Language Server (csharp-ls) on an Air-Gapped Windows System
• Shells:
  • Charles Choi: Take Two: Eshell
  • Irreal: How To Stop Emacs From Asking For Aliases change eshell-bad-command-tolerance or eshell-alternate-command-hook
• AI:
  • mcp-server.el - implementing MCP servers in elisp (Reddit)
  • [ANN] - Wingman: LLM-assisted Copilot-style text completion (Reddit)
  • Announcing Claude Code IDE: MCP based Claude Code and Emacs integration (Reddit)
  • Emacs AI plugins (40:06)
• Community:
  • Ross A. Baker: Take Two: Coming Home to Emacs (@ross@social.rossabaker.com)
  • Those who switched from Vim/Neovim - what's your story? (Reddit)
  • My Emacs journey (2) - Vanilla | Donovan R. (Irreal)
• Multimedia:
  • snowy-0wl/piper-mode: High-quality text-to-speech for Emacs using the Piper TTS engine. Natural-sounding voice synthesis, multiple voice commands, and automatic setup. macOS/Apple Silicon (HN)
• Other:
  • Announcing Casual Man & Help (Reddit, Irreal)
  • View and Annotate Your PDFS in Emacs – Pdf-tools and Org-noter (04:53)
  • Emacs Reader 0.3.0 (Lambdex) (@divyaranjan@mathstodon.xyz) - refactoring, bugfixes, removed mupdf submodule
  • Peter Tillemans: Consolidating Secrets in Pass
  • Emacs trial & editor configuration (05:05:19)
  • How to Install Emacs on Windows 11 (02:39)
  • GNU Emacs【※音無し】 (03:17)
• Emacs development:
  • 'C-u C-x .' clears the fill prefix
  • New user option vc-dir-save-some-buffers-on-revert
  • Allow automatically delete non-existent projects. (Bug#77566)
  • Load site-start.el before early-init.el
• New packages:
  • conventional: Enable conventional syntax (MELPA)
  • deflate: The DEFLATE compression algorithm in pure Emacs LISP (MELPA)
  • easy-find: Simple file searching like Nemo (MELPA)
  • elisp-dev-mcp: MCP server for agentic Elisp development (MELPA)
  • gptel-commit: Generate commit message with gptel (MELPA)
  • greger: Agentic coding environment with tool use, using Claude (MELPA)
  • hdf5-viewer: Major mode for viewing HDF5 files (MELPA)
  • helix: A minor mode emulating Helix keybindings (MELPA)
  • nerd-icons-xref: Add nerd-icons to xref buffers (MELPA)
  • simply-annotate: Enhanced annotation system with threading (MELPA)
  • slothbar: Emacs X window manager status bar (MELPA)
  • virtual-ring: Fixed size rings with virtual rotation (MELPA)
  • wilson-ng-theme: A modernized version of the Wilson theme (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, 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.

This is a contribution to the Emacs Carnival 2025-06: Take Two collection of posts on Christian Tietze’s blog.

My first take with Eshell many years back did not leave a good impression. My early expectations was that it should act like any other shell, only to be unpleasantly surprised by it. It took a long time for me to warm up to Eshell. Upon reflection, it was because I wasn’t ready for it.

Now Eshell is an inseparable part of my Emacs experience. Paradoxically though, I find little occasion to use Eshell in the same way I’ve used shells in the past. Much of what I used to use the shell for, I do today with Emacs modes instead.

It was not always this way. Like so many users who started Unix computing in the 80’s, I started with the command line (for myself ksh and later bash), studiously internalizing command line tools and their arcane syntaxes to support file management, running programs, and systems administration. Overwhelmingly though, it was file management and running programs that I did through the command line.

For file management these days, Dired is my interface of choice. It is simply the more elegant tool for the job.

Case in point: renaming a bunch of files in a directory to arbitrary names. With a shell, my standard approach would have been to run some variant of ls -1 > foo.sh, edit foo.sh to insert mv on each line to a renamed target file, chmod u+x foo.sh to be executable, run foo.sh, delete foo.sh and call it a day.

With Dired, the above steps are replaced as such: make the buffer writable (via Wdired). Change the target filenames to a desired result, then commit the changes. This is even easier if there is a pattern you can use a regexp for. Unsurprisingly, all the basic file management operations that you would want are supported by Dired. Add Casual Dired to help make these operations discoverable and you’ll soon consider how quaint using mv, cp, rm, and ls are.

Running a simple command on a file? Again, you can do that with Dired. Move the point to the Dired line containing the file. Type “!” and enter a command in the prompt. You can optionally reference the filename in the command with the “?” character if you want to redirect its output to a file (e.g. cmd ? > outfile).

Taking file management and running simple commands out of what you would use a shell for, what’s left over? Source code management (SCM)?

Like for many others, git is my goto tool for SCM. Much has been said about the terrible user experience of the git command line and for years I suffered with its design decisions. Thankfully for Emacs users, there is Magit and VC mode which both provide a saner experience for it.

Running a Makefile? Use Emacs compile, which provides command completion for the targets defined in the Makefile and error/warning navigation if needed. (Try out Casual Make for editing Makefiles in Emacs.)

Do you need to run a command with arcane arguments repeatedly? Again, Makefile + compile to the rescue where it can be used as a task runner for that command.

Need robust terminal emulation? Eshell will fail you here and you are likely better off using a dedicated terminal emulator app, separate from Emacs. That said, I’ve found the built-in term to be good enough for many curses-style utilities.

Mining data files with piped commands? Eshell is a power tool here: used wrongly and you could figuratively cut off a limb. But used cleverly, Eshell offers great value. More on this later.

So with all these use cases described, why even use Eshell?

Using Eshell becomes a win only if you know Elisp. With that, you can think of Eshell as an Elisp REPL that can secondarily act as a shell.

Let’s not mince words. For many users this is a high bar, as it takes into account a lot of prerequisite knowledge. That said, learning basic Elisp is trivial for readers already conversant with programming and manageable for those that aren’t. Personally, I was very late (decades!) in taking the time to learn Elisp because I didn’t see the reward in it and so, prioritized accordingly. That hesitancy turned out to be unfounded. Elisp is easy to learn and the reward (or punishment) for knowing it is having the ability to really use the full capabilities of Emacs. (Know Python? Here’s a cheatsheat for Elisp that I wrote, hop in, the water’s fine…)

Once gained, bringing Elisp knowledge to using Eshell gives you a command line super power: the ability to improvise shell commands with Elisp functions.

Consider the following Eshell example where we wish to apply a command on a set of png files in a directory. Let’s start with a simple example that simply echoes filenames with suffix .png.

$ for i in *.png { echo $i }

In Eshell, you can replace echo $i with an Elisp expression.

$ for i in *.png { (format "%s" i) }

You can also mix shell commands and Elisp via dollar ($) expansion. Note that $ expansion in Eshell is different from other shells. A deeper reading is on it is recommended to avoid confusion with what works in conventional shells.

$ for i in *.png { echo $(format "%s" i) }

If you have ImageMagick, installed, you can use the convert utility to change this to a jpeg file, using the Elisp file name components functions to do the work of getting a desired target name.

$ for i in *.png { convert $i $(file-name-with-extension i "jpg") }

Contrast this with the equivalent expression in Bash which I consider to have much more forgettable syntax.

$ for i in *.png; do convert $i ${i/.png/.jpg}; done

Another significance with mixing shell commands and Elisp together is the ability to incorporate Emacs buffers into an improvised workflow. Shell commands are typically designed to work with data organized as files. In contrast, Elisp (rather, Emacs) treats files as a persisted, secondary form of data. Instead, Buffers are the primary data type in Emacs.

Recall the Dired naming example above? Consider the added steps due to using a temporary file foo.sh compared to using a writeable Dired buffer.

Eshell shifts you into thinking differently about working with a prompt, where instead of thinking of output being only a file or (stdout, stderr), the output could also be an Emacs buffer.

With that change in thinking, Eshell is better thought of as a “prompt” interface for Emacs which in turn serves as the interface to all the command line utilities made available to it. In this light, a whole swath of common shell workflows get replaced by Emacs.

Suffice to say, Eshell reinforces and rewards keeping Emacs users only in Emacs.

Another common shell workflow is using grep with pipes (|) for data mining files. For example:

$ grep {pat1} {file} | grep -v {pat2} | grep {pat3} >outfile

Using this pattern indiscriminately in Eshell is a recipe for unpleasant surprise if the file to be mined is large. This is because Eshell will ingest said file into Emacs as part of the pipeline processing. This will be slow. To avoid this, you can prefix each | with an * as follows:

$ grep {pat1} {file} *| grep -v {pat2} *| grep {pat3} >outfile

Why store a result in a file (outfile) that you have to open to see it and may not care to keep around? Here Eshell gives you the ability to redirect to a buffer.

$ grep {pat1} {file} *| grep -v {pat2} *| grep {pat3} >#<buffer "*my grep results*">

Note that Eshell supports creating/overwriting (>) and appending (>>) for redirection. Use > with care when working with an existing buffer.

What about piping shell command output to an Elisp function? At the time of this writing, you really can’t though according to this Reddit thread, this may change in the future.

If you are used to workflows that bleed out megabytes of data to stdout, you really shouldn’t use Eshell. But with some cleverness, Eshell can help you get insights to your data faster by leveraging all the tools Emacs can offer for this (occur, highlighting, grep, etc.).

Closing Thoughts

IMHO, Eshell is best thought primarily as a prompt for Elisp/Emacs functionality with the secondary benefit of running command line utilities with a “shell-like” experience. It should not be thought of as a “drop-in” replacement for an actual terminal shell. If full terminal emulation is desired, my guidance is to run a dedicated terminal emulator outside of Emacs.

To get the full benefit of using Eshell, you really need to be conversant with Elisp. That said, Eshell is actually a great way to start learning Elisp as it provides you a prompt interface (REPL) in much the same way that other languages like Python, JavaScript, Ruby, Java, Swift, etc do.¹ Especially if you are comfortable with programming, take a day to learn Elisp. You won’t regret it.

Bringing Eshell into my Emacs journey has been amazing and I’m happy to have given it a second take.

Thanks to all the contributors of Eshell.

Footnotes

¹ To clarify, these languages adopted the idea of a REPL from Lisp development which Elisp is descended from.

Flandrew likes Org mode but he wanted to improve his workflow with it a bit. So he wrote some code that he called Fold and Focus—Focused Navigation. The idea was that when in Org mode a single key would move to the next or previous subtree, position that subtree at the same place on the screen, and have everything else folded so that he could concentrate on the current subtree.

That worked out pretty well but after a while wanted to bring the same sort of functionality to Elisp buffers, which he did. Recently, while working in a Markdown buffer, he automatically tried to navigate in the same way but, of course, it didn’t work. So he did the natural thing and ported focused navigation to work in Markdown buffers.

I don’t use Markdown so I have no use for this functionality but it seems like a really useful addition to your toolkit if you do. Take a look at flandrew’s posts. He has animations that show how it works in all three environments. If the project seems interesting to you, take a look at the project page.

It is month two of the Emacs Carnival and I am hosting July with the topic of "Writing Experience".

This is such a wide ranging topic but one I know the Emacs community and beyond loves to discuss. It usually produces some interesting posts and workflows. Whether you are writing novels, zettlekasten or simply taking notes, what is your writing experience in Emacs. Denote, Howm, Orgmode, Org-Roam, Journal, it doesn't matter. How does your writing workflow in Emacs translate to your mobile devices? What are your pain points? What are your successes? Lay it all out there.

I'm hoping the July topic produces new ideas and inspiration. Have fun with it.

What’s a Blog Carnival, Again?

(Copied from Christian Tietze introductory post)

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.

We are still needing more hosts so please volunteer if you want to host one of the months by adding your name to the EmacsWiki page.

Submissions

I'll aggregate all the submissions for July in this post. I do not yet have a contact form on this new site so you can email me at greg@gregnewman.org or DM me on Mastodon with a link to your submission.

Submissions to Date

1. Erik L. Arneson: Writing Experience (Emacs Carnival)
2. Jakub Nowak: Architecting a Better Org Workflow

Taking digital notes is something I do a lot. Not because I particularly enjoy writing all the time or because I’m especially good at it, but because I want to understand myself better and gain a little more control over my life.
Taking notes is like building a time machine that tracks how my mind works.
I do it also because it’s fun to rediscover my old self through my notes.
Sometimes I made silly decisions, other times I appeared wiser than I do today.
Sometimes I find my belief swinging from one extreme to the opposite like a pendulum.

It’s June 2025, and I want to share with you what kind of notes I take and an overview of my current workflow for note-taking.

As for today, I’m using both Logseq and Emacs to take notes.

Logseq

Logseq still holds most of my old notes, and I rely heavily on it for capturing media-related content (videos, Excalidraw diagrams, and more).

What notes do I take in Logseq?

Quotes

I capture quotes from other people that resonates with me, as well as my own insights.
I use the Logesq banner plugin to randomly display these qutes in the banner.
I love this mechanism of resurfacing quotes.

Contacts and People info

When I interact with someone, I note the interaction in the journal page, using their name as a tag (which also creates a page in Logseq).
Later, I can fill in more details about the person, such as email addresses or phone numbers on their page.
From their page, I can quickly check every interaction in the backlink section.

Youtube links

I use the youtube timestamps when learning something new or bookmarking some interesting part of a video.
This allows me to quickly jump to the relevant part later.

Excalidraw

I use the build-in excalidraw to brainstorm or create presentations.
I maintain a vertical calendar in Excalidraw where I jot down some notes about what I might want to do each month.
I use the green color to separate what’s done from the rest.
I find this gives me a convenient overview of the year.

Presentation

Logseq is excellent at structuring ideas with bullet points.
The Bullet Threading plugin combined with the built-in zoom in / out feature of Logseq makes it a very good tool for presentation.

Emacs

I rely extensively on Org mode for note-taking on Emacs.

What notes do I take in Emacs?

Long-form notes

Insights, Technical documentation, Blog Posts, Journals, etc, when I’m in the mood for a long-form writing, I switch to Denote and start typing.
I don’t use many of Denote’s features. I just run M-x denote , fill in the title and tag, and start writing.
It’s simple and gets the job done!

Project

I have a folder named project where I put org file for each project I’m working on.
I don’t use a specific structure yet. Just bullet points for todos and scheduled items with notes for each project task.
The org files are linked to Org agenda for convenience.

Time tracker

Similarly, I have org files for tasks. For example work.org for work-related tasks.
I track the time I’m working on tasks using org-timer-set-timer combined with org-clock-in and org-clock-out.
And I use Org capture template for convenience.

Event Scheduling and Agenda

As above, I have an agenda.org file that is linked to my Org agenda for all my scheduled event.
Using of course org-schedule for scheduling a task.

Synchronization

Wether I’m using Logseq or Emacs, all my notes are linked to a private Git repository. This setup ensures that my data is always synchronized and backed up.
It’s simple and reliable.

In summary

This is my current workflow. Nothing set in stone, just how I do things right now.
Like everything else, it changes and evolves over time as I learn and grow.
Who know what it’ll look like in the next month or next year?
For now, this is what works for me.

Today (Saturday) appears to be a slow day on the technical Internet or perhaps everyone is hiding out from the AI apocalypse. Whatever the reason, I can’t find anything to write about that’s up to the refined standards of Irreal readers.

I offer, therefore, this short post on a niche problem that most of you probably don’t have but that may be useful to those that do. If you’re an Eshell user you may or may not know that if you repeatedly try to run a command that doesn’t exist, Eshell will ask you if you want to set an alias. Over at the Emacs subreddit, Both_Confidence_4147 complains about this and asks how to stop it.

Presumably, Eshell thinks you’re repeatedly mistyping the command name—as in the old time common error or typing “moer” for “more” and similar errors—and is offering you a way to avoid the error going forward. Eshell will ask you for an alias after 3 failed commands but, of course, this is configurable. You can also arrange to disable the prompt completely as explained in this comment to Both_Confidence_4147’s post.

Again, this is a niche problem unless, of course, you’re the own who’s experiencing it. If you are, now you know how to fix things.

I found out about Harper the other day. Ever since I heard about it, I've been itching to set it up in my config and get rid of the horrible LanguageTool setup I had going. Now that I've got it working, I've gotta say I'm quite impressed. My previous LanguageTool setup was not smooth at all, and definitely not as fast as Harper is. I'm not sure how anyone else is doing spellchecking in Emacs (and particularly in org-mode) at the moment, but I recommend anyone using Emacs for most of their writing to give it a shot.

I won't embarrass myself with a comparison of my LanguageTool config. Just know that it was slow and terrible. Copied from the Harper docs, this is what my config looks like:

(when (and (not (equal system-type 'windows-nt)) (locate-file "harper-ls" exec-path))
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs
               '(org-mode . ("harper-ls" "--stdio"))))

  (setq-default eglot-workspace-configuration
              '(:harper-ls (:dialect "Australian")))

  (add-hook 'org-mode-hook 'eglot-ensure))

Some caveats: it doesn't look like Harper has support for org-mode specifically yet, but it seems to generally work OK despite that. I have however noticed that it doesn't lint property tags, so for example your #+title: won't be spellchecked. Another minorly annoying little niggle is that straight seems to misbehave with eglot, or eldoc more specifically, printing eldoc error: (invalid-function incf) in the minibuffer instead of an actual error message. I was using lsp-mode before this - although I'm beginning to like the eglot interface more and more as I write this, so I think I may swap over to it where possible - so I never realised this issue. Per that GitHub issue link, (use-package eldoc :straight (:type built-in)) seems to be the solution.

The only thing that's missing, and to be fair LanguageTool doesn't implement this either (in fact to my knowledge nothing implements this, I don't even think there's a Word plugin), is text style metrics analysis. Every so often I get the impulse to try to untangle what the source code for that website is doing, and then write a simple elisp wrapper for it, but I always get sidetracked before I start. Maybe now is the time.

(if (file-exists-p "/usr/bin/hunspell")
    (progn
      (eval-after-load "ispell"
        '(progn
         (setq ispell-program-name "hunspell"
               ispell-dictionary   "en_AU"
               ispell-alternate-dictionary (file-truename (concat user-emacs-directory "en_AU.dict"))
               ispell-local-dictionary-alist '(("en_AU" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_AU,en_AU-med") nil utf-8)))
         (defun ispell-get-coding-system () 'utf-8)))
      (eval-after-load "flyspell"
        '(progn
         (setq ispell-program-name "hunspell"
               ispell-dictionary   "en_AU"
               ispell-alternate-dictionary (file-truename (concat user-emacs-directory "en_AU.dict"))
               ispell-local-dictionary-alist '(("en_AU" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_AU,en_AU-med") nil utf-8)))
         (defun ispell-get-coding-system () 'utf-8)))))

This post is my contribution to the Emacs Carnival June 2025 topic "Take Two" set by Christian Tietze. This is also a cross post for the IndieWeb Carnival: Take Two which was the original inspiration behind the Emacs Carnival. You can get more information about the Emacs Carnival on the wiki.

I started using Emacs about 20 years ago. From the start I was heavily involved in the Emacs IRC channel and the Org mode mailing list. I contributed the refresh of the Org mode logo to Dr. Carsten Dominik and the community as a small thank you for such a great package. All my notes were stored in Org mode files, along with my task lists. For development I used Elpy for Python and Webmode for anything HTML and Javascript. Elpy was good enough for me back then. Webmode was just ok but had a lot of problems with javascript. I jumped over to LSP mode pretty early and that solved a lot of problems with Python but it was a pain to configure and broke at the most inconvenient times. I was frustrated a lot of the time I was trying to work.

Around 2015 I was introduced to PyCharm by a client. The debugger was fantastic and hooked me quickly. It replaced a lot of what I was using Emacs for. I still used Emacs but jumped back and forth between the two (a lot of things are just easier in Emacs). Around the same time I started working with React and I could never get anything working well in Emacs, but PyCharm just worked. So I stayed with PyCharm for many years (mostly). All my notes were still stored in Org mode files (and most still are). I still have notes in org files from nearly 20 years ago. I can't say that about any other notes apps.

When Eglot started gaining momentum I decided to see what it could do. I was pleasantly surprised but it did not fully bring me back. It was still easier to just use PyCharm. PyCharm is a great IDE but I find IDEs too opinionated. I always had the itch to return to Emacs for all my development needs. A year or two ago I decided to give Eglot another try. It had matured - or perhaps I had. I played around with the available options for LSP and found Pyright to be very good. I was able to get my Emacs config to provide me with most of what PyCharm was handling. When I finally upgraded Emacs from 29 to 30, I stopped using PyCharm. With Eglot, the current options for Language Servers, and Tree-sitter I now have a stable environment for Python/Django work as well as React. I'm now comfortable with my environment.

Currently, I'm using Eglot with Basedpyright Language Server and Ruff for linting. For React/Javascript I'm using the Typescript Language Server. Below is my current Eglot config. It has taken many iterations to get it where I'm happy with it. I still need to add JS linting to it but for now that's mostly covered in my pre-commit hooks.

  (use-package eglot
    :straight t
    :ensure t
    :defer t
    :custom
    ;; Optimize performance
    (eglot-send-changes-idle-time 0.5)
    (eglot-extend-to-xref t)
    ;; Configure language servers
    (eglot-server-programs
     '((python-ts-mode . ("basedpyright-langserver" "--stdio" 
                          :initializationOptions (:basedpyright (:plugins (
                             :ruff (:enabled t
                                   :lineLength 88
                                   :exclude ["E501"]  ; Disable line length warnings
                                   :select ["E", "F", "I", "UP"])  ; Enable specific rule families
                             :pycodestyle (:enabled nil)  ; Disable other linters since we're using ruff
                             :pyflakes (:enabled nil)
                             :pylint (:enabled nil)
                             :rope_completion (:enabled t)
                             :autopep8 (:enabled nil))))))
       ((js-ts-mode typescript-ts-mode tsx-ts-mode) .
        ("typescript-language-server" "--stdio"))))
    :config
    (setq-default
       eglot-workspace-configuration
       '(:basedpyright (
           :typeCheckingMode "off"
         )
         :basedpyright.analysis (
           :diagnosticSeverityOverrides (
             :reportUnusedCallResult "none"
           )
           :inlayHints (
             :callArgumentNames :json-false
           )
         )))
    :bind (:map eglot-mode-map
                ("C-c l a" . eglot-code-actions)
                ("C-c l r" . eglot-rename)
                ("C-c l f" . eglot-format)
                ("C-c l d" . eldoc)
                ("C-c l o" . eglot-code-action-organize-imports)
                ("C-c l h" . eglot-inlay-hints-mode)
                ("C-c l q" . eglot-shutdown-all))
    :hook ((python-ts-mode . eglot-ensure)
           (js-ts-mode . eglot-ensure)
           (typescript-ts-mode . eglot-ensure)
           (tsx-ts-mode . eglot-ensure)
           ;; Python-specific settings
           (python-ts-mode . (lambda ()
                               (setq-local indent-tabs-mode nil
                                           tab-width 4
                                           python-indent-offset 4)
                               (superword-mode 1)
                               (hs-minor-mode 1)
                               (set-fill-column 88)
                               (display-line-numbers-mode 1)))))

Background

Like a lot of people I've had a long history managing passwords and secrets over the years. From a little black book, over an Excel sheet, using a GPG encoded secrets file (works really well with Emacs gpg support), 1password (till they racked up their prices), lastpass (till they got bought by the Evil LogMeIn Corp), KeepassXC and lately pass.

I was perfectly happy with KeepassXC for a very long time, except for the command line integration. So I kept ending up with passwords in .envrc files in folders and excluded in the global .gitignore to avoid too many red cheeks. While this does keep secrets out of harms way mostly, it kept nagging that I had them in plain text in those files. In theory there is keepassxc-cli to query the passwords from the command line, but let's say the experience does not spark joy. It has no easy way to cache the password between calls and it is optimized for interactive use. (AFAICT, just the giant size of the command to type gives me dread).

Some day I stumbled over pass and found that after setup I could just pass snamellit/website to get the password on stdout. I wrote about the setup and emacs integration in a previous post. Since it leverage gpg, password caching is handled by the gpg-agent and my .envrc files quickly were purged of blasphemous secrets, replace by pure bliss:

export MY_SECRET=$(pass my/secret)
export OTHER_SECRET=$(pass other/secret)

similarly in emacs I can consistently get my passwords and related info with:

(org-gcal-client-id (auth-source-pass-get 'secret "snamellit/org-gcal-client"))
(org-gcal-client-secret (auth-source-pass-get "id"
"snamellit/org-gcal-client"))

When needed the gpg-agent will launch the appropriate pin-entry program whether in terminal or in the GUI and the caching will not force me to login several times when entering the folder.

So I ended up with my interactive use covered by KeepassXC and automated use by pass.

However, after some time I ended up with hundreds of secrets in KeepassXC, hundreds in pass, it is not always clear whether use is interactive or automated so confusion and duplication starts and things become harder to manage. In addition KeepassXC was using historically Dropbox to make it available on all my devices, recently migrated to Nextcloud, which has issues with dealing with conflicts which occasionally bite me in the behind. On the other hand pass secrets are stored encrypted in git where conflict punch you in the face. I prefer the latter. And started contemplating whether to move everything to pass.

Thanks to the encouragement of SummerEmacs, one of the more enthusiastic SystemCrafters, ensuring the great experience in browsers and iOS mobile devices I had no more excuses to keep postponing it.

Preparation

I started out with keeping my pass passwords as part of my dotfiles. This was convenient when they were few. However this is weird so this will attract weirdness when configuring all integrations I'll need.

Also pass supports a git command to manage the password-store with git which is not really useful when it is part of something else. So the first order of the day is to move all secrets to a separate repository and update the dotfiles to check for presence and clone the repo if missing (and do a gently pull when it is). A quick visit to each of the machines in my machine park to apply this change. Everything still seems to be working.

Migration of the KeepassXC data

I used the pass-import tool which adds in import command to pass which supports a crazy amount of password managers, including keepassxc. For keepassxc it need the pykeepass. If you're running on Arch, everything is a yay -S away. However on Ubuntu and its derivatives it is the usual slog we start to get accustomed to. It's all in the pass-import README , note that on Ubunty the pykeepass library is available with apt install python3-pykeepass.

Once it is installed I tried a dry run (with the -d flag) to see if basic functionality is working

pass import -a -d keepassxc ~/Nextcloud/Apps/Keepassxc/Passwords.kdbx
Password for /home/pti/Nextcloud/Apps/Keepassxc/Passwords.kdbx:
  w  Data would be imported from keepassxc to pass
  .   Passwords imported from: /home/pti/Nextcloud/Apps/Keepassxc/Passwords.kdbx
  .   Passwords exported to: /home/pti/.password-store
  .   Number of password imported: 2035
  .   All data imported
  w  Weak password detected: eDGQqipE might be weak.  Score 2 (100000001 guesses).  This estimate is based on the sequence eDGQqipE(bruteforce)
  w  Weak password detected: eDGQqipE might be weak.  Score 2 (100000001 guesses).  This estimate is based on the sequence eDGQqipE(bruteforce)
  w  Weak password detected: eDGQqipE might be weak.  Score 2 (100000001 guesses).  This estimate is based on the sequence eDGQqipE(bruteforce)
...  large list of names of secrets

This asks for the password of the Keepass file and some remarks it has.

This all looks reasonable. So we can try the import. Since the password-store is a git repo no real damage can be done to it (as it is safely pushed somewhere else where the import tool cannot touch it) and any damage done can be reverted....

Now is a good time to check if the mooring lines of your laptop are properly secured as encrypting all the secrets will spin up the propellors if the number is large enough.

I run it again without the -d flag and after several minutes the noise dies down and I am left with a lot of additional folders in my ~/.password-store which match the grouping in KeepassXC. The files contain the secrets and the expected metadata. This looks good so I add/commit the things to complete the level.

Integration with iOS for my iPhone

Let's start with the most scary one : the iPhone.

Upon recommendation I had installed passforios which needs to be configured.

Configuring the host, repo and username to use for the git repository is straightforward enough.

I always use ssh to access my repos so we need to add an ssh keypair for this purpose. There is no support to generate key-pairs in passforios for reasons, so I have to do it externally and upload the key. A quick ssh-keygen , uploading the public key to the forge, allowing access to the repo and if I can get the private key on my phone we can access the repo.

passforios has a nice feature to load ascii armored keys via a QR code. A bit digging surfaced the asc-key-to-qr-code-gif tool which was made for this specific purpose. The ssh key is already in the appropriate format so this can be directly converted

./asc-to-gif.sh ~/.ssh/id-passforios ssh-pub.gif
display ssh-pub.gif

Then go to the repository settings, press the circled i on the SSH Key button, select the ASCII-Armor Key and click to scan the QR code. Point the camera to the QR code on the screen and it should appear in the key field in the app.

We have to repeat this 2 more times to get the private and public key for the password-store into the app. First exporting the keys

gpg --export -a 1234ABCD >gpg.pub
gpg --export-secret-key -a 1234ABCD >gpg.key

converting to a gif, displaying them and scanning them in *Settings -> PGP Key -> ASCII-Armor Key in the respective fields.

If, after synching, you go now to the Passwords you should be greeted with a listing of all folders and keys and the secrets should be visible if made visible by tapping the eye icon.

I needed to enable passforios as a source for autofill : Settings -> Passwords -> Autofill Passwords and slide the toggle for Pass. I also disabled the toggle for Strongbox which I was using for integration with the Keepass database.

Now I see the option to select the secrets from the passforios app. It does not narrow down to the right key, but that is a problem for future me.

Ok, the hard part is done. Or at least the most risky part, ... in my eyes... whatever. Moving on...

Integration with FireFox

Checking at the bottom of the pass website we find that passff is the good stuff for integration with FireFox. From previous adventures with KeepassXC and NativeMessaging I assumed there had to be a host part to be installed too.

Indeed we are directed to the passff-host github repo to get an install-script which generates the native messaging json for the different browsers and a small executable python script which contains remarkable clean and no-dependency code. Similarly the install script is straightforward. I do not understand why it support half a dozen browser, mostly chrome based as for the life of me I cannot find an extension which uses this host program. So either I need bigger glasses or there is some knowledge beyond my grasp.

Running the installer, installing the extension, restarting firefox for good luck and the extension appears and offers passwords on the sites I try.

Out of curiosity I check the configuration in ~.mozilla/native-messaging :

pti@tuxedo ~> ls .mozilla/native-messaging-hosts/
org.keepassxc.keepassxc_browser.json  passff.json  passff.py*
pti@tuxedo ~> cat .mozilla/native-messaging-hosts/passff.json
{
  "name": "passff",
  "description": "Host for communicating with zx2c4 pass",
  "path": "/home/pti/.mozilla/native-messaging-hosts/passff.py",
  "type": "stdio",
  "allowed_extensions": [ "passff@invicem.pro" ]
}
pti@tuxedo ~> cat .mozilla/native-messaging-hosts/passff.py
#!/usr/bin/python3
"""
    Host application of the browser extension PassFF
    that wraps around the zx2c4 pass script.
"""

import json
...

Nothing out of the ordinary, the passff.py python is the same as in the repo. My old keepassxc extension support is still there.

Firefox is installed natively on this machine, not with a flatpak which I assume will come with its own challenges.

Chromium Support

Time to tackle the Chrome family. Chrome is required to put food on the table so we have to get that going eventually. But Chrome is distributed as a flatpak (or a snap but I am NOT going to deal with that), and I can install Chromium natively, and apparently native installs are MUCH better supported than the versions in wrappers so let's start with that one first.

From the pass website we find that browserpass is the way to go for the chrome family. The browser extension installs from the usual places without drama and starts promptly complaining it cannot find the native host to talk to.

The native host in question is from the browsaerpass-native sister repo . As usual for all distro's there are packages ready to install but because Ubuntu-derivative I can compile from source. Downloading the source for version 3.1.0 from the releases page. Again this repo refers to all browsers including firefox although I cannot for the life of me find a Firefox Extension supporting this host app.

Then building and installing timelapse :

tar -xzvf ~/Downloads/browserpass-native-3.1.0.tar.gz
cd browserpass-native-3.1.0
ls
less README.md
PREFIX=/usr/local make configure
sudo make PREFIX=/usr/local install
which browserpass

which shows the executable lives at /usr/local/bin/browserpass and this totally went fine the first time (NOT!!!!).

The Makefile has support to install the magic json to enable native messaging for the different browsers.

PREFIX=/usr/local make hosts-chromium-user
PREFIX=/usr/local make hosts-chrome-user

The second invocation is a hail-mary because I already know the Chrome flatpak does not look in the same places and will require some additional finnagling

For now focus on Chromium and check if the configuration looks reasonable:

pti@tuxedo ~> cd .config/chromium/NativeMessagingHosts/
pti@tuxedo ~/.c/c/NativeMessagingHosts> ls
com.github.browserpass.native.json@
pti@tuxedo ~/.c/c/NativeMessagingHosts> cat com.github.browserpass.native.json
{
    "name": "com.github.browserpass.native",
    "description": "Browserpass native component for the Chromium extension",
    "path": "/usr/local/bin/browserpass",
    "type": "stdio",
    "allowed_origins": [
        "chrome-extension://naepdomgkenhinolocfifgehidddafch/",
        "chrome-extension://pjmbgaakjkbhpopmakjoedenlfdmcdgm/",
        "chrome-extension://klfoddkbhleoaabpmiigbmpbjfljimgb/"
    ]
}

Cool, the executable is looked at where it is installed (this is not obvious, don't ask how I know). The rest looks also like how these things should look. Let's try...

The extension settings page is no longer complaining the native host is missing and there are password entries visible. Checking with some website shows the password is injected. yay!.

Level complete, ready for the final boss.

Enabling Chrome Support, now with more Flatpak!

Ok, we have a working chromium support so repo access, host app, native host configuration et al are proven working. We can only focus on jumping over the Flatpak Firewall...

As a good cargo cultist I do a literature study and find that I should

• find the config location of the flatpak app

• use flatpak-spawn to spawn the native messaging host app

• enable D-Bus Session socket access for chrome

• Package up the calling of the host app in a single script to configure in the json.

  Not necessarily in that order....

For the permission to access D-Bus Session start up flatseal from flathub, navigate to com.google.Chrome and enable the D-Bus Session socket. This should be possible with some additional cursing in the manifest file of Chrome. I cannot find decent reference documentation in a reasonable time, so flatseal it is.

The configuration of the flatpak app is easy too, painful experience seared in my brain that flatpaks look in ~/.var/app/ folder so for Chrome this will be ~/.var/app/com.google.Chrome . From the hail-mary install for chrome done above I know that it just creates a symbolic link to /usr/local/lib/browserpass/hosts/chromium/com.github.browserpass.native so we can start from there. We will have to edit that so copy it. We also need a wrapper to call the native host app

cd ~/.var/app/com.google.Chrome/config/google-chrome/NativeMessagingHosts
cp /usr/local/lib/browserpass/hosts/chromium/com.github.browserpass.native
ec browserpass.sh

Add the content of the wrapper

#!/bin/sh
cd ~
/usr/bin/flatpak-spawn --host /usr/local/bin/browserpass 2>/tmp/browserpass-error.log

I added the optional redirect of stderr to an error logfile because from experience I know nothing ever goes wrong if you enable error reporting beforehand.

chmod +x browserpass.sh
pwd
pwd | wl-copy
ec com.github.browserpass.native.json

Installing the browserpass extension in Chrome after restarting it (I am not superstitious, just careful) and I can bask in the glory of seeing proposals for passwords when trying to log in. Most of the proposals are pretty garbage, but that is a problem for future me.

Conclusion

I have access to my password-store secrets on my phone, my browsers on laptop and desktop, and most importantly Emacs. Narrowing of the proposed secrets is, euhmmm, sub-optimal, but since it is sub-optimal in the same way on all platforms I assume that some TLC in the password-store and cleaning of the migrated secrets will fix that in time.

In the process I gained much more confidence in configuring flatpak apps. I can decommission the keepassxc system including dealing with the sync conflicts (which was admittedly super easy with the merge database feature in KeepassXC). I no longer have to deal with giving the KeepassXC window a place on the desktop and autostarting it.

I am a bit puzzled about the host-apps referring to supporting browsers for which no extensions are available. This probably might warrant some additional investigation.

Big step forward

This month’s Emacs Asia-Pacific (APAC) virtual meetup is scheduled for Saturday, June 28, 2025 with BigBlueButton and #emacs on Libera Chat IRC. The timing will be 1400 to 1500 IST.

The meetup might get extended by 30 minutes if there is any talk, this page will be updated accordingly.

If you would like to give a demo or talk (maximum 20 minutes) on GNU Emacs or any variant, please contact bhavin192 on Libera Chat with your talk details:

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.4.0 on 2025-06-28

This version adds some minor improvements to a stable package.

Per-frame Xref histories

The built-in Xref mechanism is typically used to navigate to the definition of the symbol at point in a programming major mode. The command xref-find-definitions (M-. by default) jumps to the source, while xref-go-back (M-, by default) goes back in the history of visited positions until it reaches the starting point.

When beframe-mode is enabled, each new frame has its own Xref history. This means that finding a definition in one frame does not interfere with the Xref history of another frame.

“Beframed” buffer prompt text is now optional

When beframe-mode is enabled, it sets the standard read-buffer-function to one that filters buffers by frame. Any command that uses that, such as switch-to-buffer (C-x b by default) is thus beframing its completion candidates.

Such prompts get a prefix to inform the user of their behaviour. By default this is [Beframed]: it is subject to the user option beframe-prompt-prefix. Users who do not wish to have any prefix can set this option to nil or an empty string.

When there is a string, it is styled with the face beframe-face-prompt-prefix.

For a little while now, I have been developing C# applications at work and on Windows!, possibly the perfect storm for Emacs, but actually, it copes pretty well, especially with eglot and the LSP server OmniSharp.

But recently my work setup has become even more air-gapped, and unfortunately, I reached a point where I couldn’t get eglot and OmniSharp working together. I gave it a really good try, but I think the mishmash and dependency installation madness finally took a toll.

It has something to do with trying to find MSBuild.exe, but due to my potentially wonky installation, I couldn’t figure out how to detect it. If Visual Studio is installed on the system, there are no problems; however, offline installation, even of the Community edition, is not an easy task.

So, the solution? Well, I thought I would try another C# LSP in the form of csharp-ls. Its deliverable form is a NuGet package, which can be extracted, placed in the relevant location, and then you’re pretty much off and running!

So here is how I did it:

Step 1: Download csharp-ls nuget Components

On a machine with internet access (which fortunately I do have access to):

Download csharp-ls

• Go to the csharp-ls NuGet page
• Click “Download package” to get the .nupkg file
• Rename the file from .nupkg to .zip
• Extract the contents

Step 2: Install csharp-ls (Airgapped Machine)

1. Create a directory in your Emacs installation:

         mkdir "c:\path\to\emacs\bin\csharp-ls"
   

2. Copy the extracted csharp-ls contents to this directory. The key file you need is:

         tools\net9.0\any\CSharpLanguageServer.dll
   

Step 3: Configure Emacs

Add this configuration to your Emacs init file:

;; Configure csharp-ls as the language server for C#
(setq eglot-server-programs
      '((csharp-mode . ("dotnet" "c:/path/to/emacs/bin/csharp-ls/tools/net9.0/any/CSharpLanguageServer.dll"))))

Step 4: Set Up Your C# Project Structure

Basically defining a source code collection as a project in Emacs. This can be a solution file, a source code control directory or as I generally have set up, an empty .project file

Step 5: Set up paths

This may not be needed, but for my own sanity and just in case, absorb the new directory in to the PATH and exec-path variables.

(when (eq system-type 'windows-nt)
  (let ((xPaths
         `(
           ,(expand-file-name "~/bin/csharp-ls/tools/net9.0/any")
           )))
    (setenv "PATH" (concat
                    (mapconcat 'identity xPaths ";")))
    (setq exec-path (append (split-string winPaths ";") xPaths (list "." exec-directory)))))

So it works as I had it with OmniSharp and that really is all I can ask for, lets see how I get on!