It seems like, in 2026, slow, intentional work is en vogue, with books like Burkeman’s “Meditations for Mortals” and Cal Newport’s “Slow Productivity” doing the rounds. As my friends know, I am fascinated (and inspired) by the Stoics and enjoy listening to the various teachers on Waking Up, many of whom echo the same idea: that mindful, focused effort is vastly more satisfying than responding to whatever seems urgent.

Time-blocking #

How we set intention is personal, and recommending any specific system feels trite. However, I have found that, for me, planning a rough schedule for the day—often called time-blocking—is a great way to think about what I want to do, how much of it I want to do, and when I want to do it.

Trying to follow such a schedule brings home many realities quickly:

• That the hours go by more quickly than one tends to think. For me, this is a reminder that the day is precious.
• That we often do a poor job at estimating how long work will take. Typically, we imagine we can do much more in a day than is realistic.
• That unscheduled interruptions are common. And others, like breaks for exercise, eating, etc., should be taken into consideration.

Implementation #

I use org-mode to outline my day, and have capture templates for each week and each day. For this year, I have a file 2026.org in which I capture all those entries.

The day planner template is most relevant here:

** %u

- [ ] Scan [[mu4e:query:maildir:/INBOX flag:flagged][pinned emails]] for new tasks (max 10 mins)
- [ ] Scan [[https://github.com/notifications][GitHub]] for new tasks (max 10 mins)

*** Plan
**** 
**** Lunch + walk <%<%Y-%m-%d %a 13:00-13:45>>
**** 
**** Tidy up <%<%Y-%m-%d %a 16:45-17:00>>

*** Notes

It is then hooked up to my org-capture-templates. I use org-indent mode, so all those heading stars collapse.

The part I’d like to discuss in this post is the “Plan” section, where I outline my work for the day.

The time stamps in org-mode are neat: you’ll see the lunch entry goes from 13:00 to 13:45 (and this is how it is stored on disk), but when modifying it in org-mode it is displayed for editing in the minibuffer as 13:00+0:45. This makes it very easy to adjust the duration of an event. Note that the day timestamp (%u) is inactive, whereas the time blocks are active, so that only the latter appear in today’s Agenda view.

Elisp functions #

The above template is sufficient for doing time blocking in org-mode. However, we can reduce some friction in how we use it by adding some utility functions for common activities.

Here are three such functions that help me to craft and modify my daily plan smoothly:

1. Quickly navigate to today’s plan

   This command is invoked inside 2026.org, and navigates to the current week, then day, then to the end of the “Plan” entry.

   (defun stefanv/org-jump-to-today-plan ()
     "Jump to the end of the 'Plan' heading under today's date headline."
     (interactive)
     (let* ((today (regexp-quote (format-time-string (org-time-stamp-format nil t))))
            (today-re (concat "^\\*+ .*?" today)))
       (goto-char (point-min))
       (if (not (re-search-forward today-re nil t))
           (message "Heading matching %s not found." today)
         (org-reveal)
         (save-restriction
           (org-narrow-to-subtree)
           (goto-char (point-min))
           ;; Matches 'Plan' heading and optional trailing tags
           (if (re-search-forward "^\\*+ Plan\\(?:[ \t]*\\(:[[:alnum:]_@:]+:\\)\\)?[ \t]*$" nil t)
             (org-end-of-subtree)
             (widen)
             (message "No exact 'Plan' heading found under today's date."))))))
   

   It specifically searches for a * Plan heading, so if you modify the template be sure to update the regexp accordingly.

2. Add a new planner entry, which follows the previous

   This function takes the end time of the previous entry, and uses it as the start time for a new entry.

   It tries to be somewhat clever at guessing your intention:

   • If you invoke it on a blank line, it searches upward for the previous timestamp, and turns the current line into a heading.
   • If invoked inside a section that already has a timestamp, it turns the next line into a timestamped heading.
   • If invoked on a heading line without a timestamp, it adds the timestamp to the end, preserving cursor position.

   (defun stefanv/org-plan-next ()
     "Create a new day plan entry following on the current or previous lines's active timestamp."
     (interactive)
     (let* ((ts-found (save-excursion
                        (end-of-line)
                        (when (re-search-backward org-ts-regexp0 nil t)
                          (let ((ctx (org-element-context)))
                            (when (eq (org-element-type ctx) 'timestamp) ctx)))))
            (is-blank (string-blank-p (buffer-substring (line-beginning-position) (line-end-position))))
            (is-header (org-at-heading-p))
            ;; Check if the found timestamp is actually on the current line
            (on-current-line (and ts-found
                                  (>= (org-element-property :begin ts-found)
                                      (line-beginning-position)))))
       (if (not ts-found)
           (user-error "No timestamp found above point")
         (cond
          ;; Already has TS OR is plain text -> new heading below
          ((or on-current-line (and (not is-blank) (not is-header)))
           (end-of-line)
           (org-insert-heading)
           (save-excursion (stefanv/insert-formatted-org-ts ts-found)))
   
          ;; Current line is blank -> turn into heading here
          (is-blank
           (org-insert-heading)
           (save-excursion (stefanv/insert-formatted-org-ts ts-found)))
   
          ;; Current line is a header (no TS) -> append TS and return cursor
          (t
           (save-excursion
             (end-of-line)
             (stefanv/insert-formatted-org-ts ts-found)))))))
   
   (defun stefanv/insert-formatted-org-ts (ts)
     "Helper to insert formatted timestamp with exactly one preceding space."
     (just-one-space)
     (insert (format "<%s %02d:%02d>"
                     (org-format-timestamp ts "%Y-%m-%d %a")
                     (or (org-element-property :hour-end ts)
                         (org-element-property :hour-start ts) 0)
                     (or (org-element-property :minute-end ts)
                         (org-element-property :minute-start ts) 0))))
   

   If you use it often, you can bind the function to a key:

   (keymap-set org-mode-map "C-c C-x p" #'stefanv/org-plan-next)
   

3. Move all timestamps in a region forward by N minutes.

   Sometimes, a day runs away from us, or we get carried away and miss the end of a timeblock. At that point, you’d likely want to shift your entire day forward. The following function lets you select several planner items and shift them all by N minutes (positive or negative). If no region is selected, operate on the current line.

   There’s some fancy footwork to ensure that the surrounding org buffer is re-rendered, especially when using org-modern.

   (defun stefanv/org-shift-timestamps-in-region (minutes)
     "Shift all active timestamps in the region (or current line) forward by MINUTES minutes."
     (interactive "nMinutes to shift: ")
     (let* ((region-active (use-region-p))
            (beg (if region-active (region-beginning) (line-beginning-position)))
            (end (copy-marker (if region-active (region-end) (line-end-position))))
            ;; Regex for active timestamps: matches < followed by anything until >
            (active-ts-re "<\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\}.*?\\)>"))
       ;; Allow undoing everything in one step
       (atomic-change-group
         (save-excursion
           (goto-char beg)
           ;; Shift active timestamps
           (while (re-search-forward active-ts-re end t)
             (save-excursion
               (goto-char (match-beginning 0))
               (org-timestamp-change minutes 'minute)
               (when (fboundp 'org-element-cache-refresh)
                 (org-element-cache-refresh (point)))))
   
           ;; Re-align tags for any headlines in the range
           (goto-char beg)
           (while (re-search-forward org-outline-regexp-bol end t)
             (org-align-tags))))
   
       ;; Refresh
       (font-lock-flush beg end)
       (set-marker end nil)
       (message "Shifted active timestamps by %s minutes." minutes)))
   

Conclusion #

I’ve presented three utility functions that help me quickly plan and organize my day. I’d love to hear from you how you plan yours!

In this post, I share the configuration I currently use, and mention some open questions I still hope to address.

Tools #

gptel is a beautifully clean and simple interface for LLM chat. Despite its simplicity, it actually has fairly advanced functionality, which includes MCP integration, introspection of queries, multi-modal input (such as images), and tool usage (extending LLMs with access to elisp functions of your choosing).

macher runs on top of gptel. It provides a “pseudo-agentic” workflow, in which you provide the LLM context about your current project, such as the list of files. It also defines several tools that the LLM can use, such as the ability to read files. You can use macher to generate a patch, which you then review, apply the parts you like, or ask macher for further improvements.

Configuration #

The macher installation simply follows the recommendations in its README:

(use-package macher
  :custom
  ;; better folding and source block highlighting of the reasoning process
  (macher-action-buffer-ui 'org)

  :config
  (macher-install)
  (macher-enable))

And here is the basic gptel configuration, ensuring that macher is pre-loaded:

(use-package gptel
  :commands (gptel gptel-mode)
  :config
  (require 'macher))

Now the model definition for Gemini, to access the latest 3.0 models:

;; https://ai.google.dev/gemini-api/docs/models
(setq
  gptel-model 'gemini-3-flash-preview
  gptel-backend (gptel-make-gemini "Gemini"
                  :key "<Get your key at aistudio.google.com>"
                  :stream t
                  :models '(gemini-3-flash-preview
                            gemini-3-pro-preview
                            gemini-2.5-flash
                            gemini-2.5-pro)))

Note how you list the models you want to choose from, and then pick the default.

You will need an API key, which you can generate at https://aistudio.google.com. I’m pretty sure you also need to activate billing to access gemini-3-flash-preview, but let me know if you succeed without doing that. My total cost, after playing around with it a bunch this week, was ~3 USD.

If your Emacs config lives in a public repository or on an untrusted machine, you’ll want to be careful in adding the token to it. gptel automatically uses tokens listed in ~/.authinfo. See Mastering Emacs for more on auth-source.

Adding Google search #

EDIT: I’ve since noticed that, while adding the search tool this way works, it also messes up macher. So, don’t try this yet until #750 is resolved.

The above configuration works fine, but I noticed that some answers were outdated. Gemini supports “grounding” via Google Search. For example, instead of telling you that TypeScript 5.3 is the newest release (which it was, at the time of its training), it can use Google Search to verify that, in fact, the latest version is 5.9.

gptel#750 tracks the issue, but in the meantime you can manually adjust the query sent to Google, and tell it to enable Grounding with Google Search:

;; Enable Google Search capability for gemini
(cl-defmethod gptel--request-data :around ((backend gptel-gemini) prompts)
  "Add search ability to Gemini requests."
  (plist-put (cl-call-next-method) :tools (append '(:google_search ()))))

This is obviously just a temporary hack, until #750 can be resolved.

Grounding with Search may incur additional costs, as per the Gemini API docs:

5,000 prompts per month (free), then (Coming soon**) $14 / 1,000 search queries

Usage #

To generate a patch on your current project, you must do two things:

1. Select project: Tell macher which project you’re working on. The easiest way to do this is to open a gptel buffer (which you can give any name you like, e.g. gemini:add-tests) and then M-x cd (change directory) into your project.

   I haven’t checked, but I suspect this requires the project to be under version control.

2. Activate macher: As part of your query, mention @macher anywhere to enable it. E.g., @macher add unit test scaffolding. C-c <enter> executes the query.

   If you type @macher and it does not get highlighted with a little box surrounding the text, then macher isn’t correctly installed. Try running M-: (macher-install) manually.

   You can add additional context to a query (e.g., a programming guidance document outside of the project) using gptel-add (this is standard gptel functionality).

While the query is executing, it displays a folded reasoning block. You can type TAB to unfold it, and watch the various steps the LLM takes. After a while, a patch will be generated in a separate window.

You can apply the entire patch using diff-apply-buffer, or single parts of the patch with diff-apply-hunk.

Issues to resolve #

With my configuration, diff-apply-buffer works fine as long as only existing files are modified. When new files need to be created, it misunderstands the file prefix in the patch, and fails to auto-complete its name. I filed an issue to discuss that with the macher author at macher#45, and hopefully can post an update soon.

Conclusion #

LLMs recently seem to have undergone a phase change in coding ability. Of course, even in this phase any code generated needs to be very carefully reviewed and tested. Andrej Karpathy’s tweet earlier today summarizes where we stand quite well (I recommend reading the top comments too).

E.g., when talking about the new capability, he also warns:

The nearest neighbor really is some kind of a junior engineer. Its ideas about what experiments to run […] have been surprisingly bad, but its execution on ideas I’ve given it have been surprisingly good. — https://x.com/karpathy/status/2015888674739912910

The mistakes have changed a lot - they are not simple syntax errors anymore, they are subtle conceptual errors that a slightly sloppy, hasty junior dev might do. The most common category is that the models make wrong assumptions on your behalf and just run along with them without checking. They also don’t manage their confusion, they don’t seek clarifications, they don’t surface inconsistencies, they don’t present tradeoffs, they don’t push back when they should, and they are still a little too sycophantic. — https://x.com/karpathy/status/2015883857489522876

So, while we should tread with care, there are exciting avenues to explore. I’ve been developing open source computational libraries for a long time, and as our ecosystem grows I notice myself spending more and more time on maintenance, and less and less time on reading papers and developing new features. My hope is that LLMs will free our small communities—who have very limited time and resources—from repetitive, tiring maintenance tasks, so we may return to what we love to do: crafting intuitive APIs around innovative algorithms that, in turn, enable real-world science.

Productivity people sure spend a lot of time writing a lot about little; and the Pomodoro technique is no exception. It can be summarized as:

Set a timer, get to work, take a break. Repeat, take a break.

There’s way too much productivity literature out there, and much of it comes down to: find a way to get your butt in the seat and start [writing/typing/reading/editing/…]. The new wave of productivity literature, or “anti-productivity” literature, tells us to face the facts: you’re never going to finish your TODO list, so give up already, be in the present, and focus on what’s most important (or, whatever, just be present).

Sometimes, I get in the flow easily, and don’t need any tricks. But other times, especially with those slightly-mundane-tasks-that-still-need-to-get-done, I need a little nudge not get started and not get distracted (by something more interesting which, in this case, may well be everything).

For me, the Pomodoro method is helpful for that purpose. And, because distraction abounds, it’s helpful to have the timer as well as the topic you’re supposed to be focused on displayed somewhere visible.

When I saw Charl’s post, I was delighted because:

1. It relies on org-mode, which I already use;
2. it does everything I used org-pomodoro for, but more simply;
3. it provides an easy path towards integration with waybar (he uses xbar for macOS, but same idea); and,
4. as observed by Charl, it does not interfere with other org clocks.

So, what follows here is a slight modification of Charl’s method, which in turn combines previous approaches by David Wilson (System Crafters) and Xiang Ji.

Emacs configuration: basic #

(require 'org-timer)

;; If you want sound when the pomodoro is over
(setq org-clock-sound (expand-file-name "~/sounds/bell.wav"))

;; And if you'd like to have a keyboard shortcut for starting a Pomodoro
(defun org-timer-start-pomodoro ()
  (interactive)
  (setq current-prefix-arg 25)
  (call-interactively 'org-timer-set-timer))
(global-set-key (kbd "C-c P") 'org-timer-start-pomodoro)

Now, when you press C-c P, a new pomodoro timer is started (you’ll see it in the mode line). You can also start it with org-timer-set-timer. After 25 minutes, when the Pomodoro is done, a system notification is displayed. Tada!

Display pomodoro status on waybar #

To display org-timer’s status on waybar, we’ll query emacs (via emacsclient¹) for its current value.

Here’s the function, org-timer-waybar-repr, which generates the status text:

(defun html-escape-string (string)
  "Escape special characters in STRING for HTML."
  (let ((result ""))
    (dolist (char (string-to-list string) result)
      (setq result
            (concat result
                    (pcase char
                      (?\& "&")
                      (?\< "&lt;")
                      (?\> "&gt;")
                      (?\" "&quot;")
                      (?\' "&#39;")
                      (_ (char-to-string char))))))))

(defun org-timer-minutes-to-string ()
  "Remaining org-timer minutes, rounded up to nearest minute, as string."
  (let* ((time-string (org-timer-value-string))
         (parts (split-string time-string ":"))
         (hours (string-to-number (nth 0 parts)))
         (minutes (string-to-number (nth 1 parts)))
         (seconds (string-to-number (nth 2 parts)))
         (total-minutes (+ (* hours 60) minutes (/ seconds 60.0))))
    (number-to-string (ceiling total-minutes))))

(defun org-timer-waybar-repr ()
  "Format org-timer status for waybar"
  (if (or (not (boundp 'org-timer-countdown-timer)) (not org-timer-countdown-timer))
    "🤗"
    (html-escape-string
      (concat
        "🍅 "(org-timer-minutes-to-string)
        "  🎯 " (org-link-display-format
                  (substring-no-properties org-timer-countdown-timer-title))))))

Next, we need a script, say org-timer-remaining, to access this text:

#/bin/sh
emacsclient --eval '(org-timer-waybar-repr)' | sed 's/"//g'

(That sed bit is to strip the surrounding quotes from the resulting string.)

To display it in waybar, we need to tell waybar to call the script at a regular interval. In ~/.config/waybar/config:

{
  ...,
  "modules-left": [..., "custom/org_timer"],
  ...,
  "custom/org_timer": {
     "exec": "~/scripts/org-timer-remaining",
     "interval": 30,
     "signal": 8
  }
}

Now, after starting a timer, you should see something like:

One little trick 🪄: do you notice the "signal": 8 above? You don’t need it, but it’s a mechanism provided by waybar for externally refreshing a widget. In this case, if we send a specific kill signal, the org-timer display will reload:

pkill -RTMIN+8 waybar

You can therefore add the following to your emacs configuration to refresh waybar the moment a pomodoro is created:

(add-hook 'org-timer-set-hook
  (lambda ()
    (start-process "waybar-timer-trigger" nil "pkill" "-RTMIN+8" "waybar")))

Things that didn’t work #

I’d have liked a tomato-themed notification for when my pomodoro expired. I can use notify-send to make that happen:

(defun pomo-notify (MSG &optional TIMEOUT)
  """Display pomodoro notification with notify-send"""
  (apply
    'start-process
    "notify-send" nil "notify-send"
    `(,@(when TIMEOUT (list (format "--expire-time=%d" (* 1000 TIMEOUT))))
       ,MSG)))

(add-hook 'org-timer-done-hook (lambda () (pomo-notify "🍅 org-timer done!")))

However, now I have two notifications popping up: mine, and the org-timer one. I tried to silence the org-timer notification using advice:

(defun suppress-org-notify (orig-fun &rest args)
  (cl-letf (
             ((symbol-function 'org-show-notification) (lambda (&rest _) (ignore)))
           )
    (apply orig-fun args)))
(advice-add 'org-timer--run-countdown-timer :around #'suppress-org-notify)

Alas, my advice fell on deaf ears. Do you perhaps know how to make it work? Let me know!

The end #

En dit is dit. Geniet die tamaties!

Updates #

Waybar: poll during timer only #

I didn’t like that the monitoring script talked to emacs every 30s, regardless of whether the timer is running. So, here is a modified version that triggers waybar updates only when the timer is started, and pauses them when the timer ends:

org-timer-remaining:

#/bin/sh

function print_status() {
  REPR=`emacsclient --eval '(org-timer-waybar-repr)' | sed 's/"//g'`
  echo $REPR
}

print_status

MONITORING="no"

trap 'MONITORING="yes"' USR1
trap 'MONITORING="no"; print_status' USR2

while true; do
  if [ $MONITORING == "yes" ]; then
    print_status
  fi
  sleep 30 &
  wait $!
done

Because the script now does the polling internally, you invoke it slightly differently from waybar:

    "custom/org_timer": {
        "exec": "~/scripts/org-timer-remaining",
    }

And, because the script handles the signals (instead of waybar), we need to update our hooks too:

(add-hook 'org-timer-set-hook
  (lambda ()
    (start-process
    "waybar-monitor-start" nil "pkill" "-USR1" "-f" "sh .*org-timer-remaining")))

(add-hook 'org-timer-done-hook
  (lambda ()
    (start-process
    "waybar-monitor-pause" nil "pkill" "-USR2" "-f" "sh .*org-timer-remaining")))

Reporting pomodoros #

It can be useful to see how many pomodoros were spent on any given project. With the modification below, we add a LOGBOOK entry to the TODO header on which the pomodoro was started upon its completion:

(defvar stefanv/pomodoro-start-time nil
  "Stores the start time of the Pomodoro timer.")

(defvar stefanv/pomodoro-start-mark nil
  "Stores a marker to the starting point of the Pomodoro.")

(defun stefanv/org-timer-start-pomodoro ()
  "Start a Pomodoro timer and record the starting point and time."
  (interactive)
  (when (string-equal major-mode "org-mode")
    (setq stefanv/pomodoro-start-time (current-time))
    (setq stefanv/pomodoro-start-mark (point-marker)))
  ;; Call org-timer-set-timer with a 1 (25 min) prefix argument
  (let ((current-prefix-arg 1))
    (call-interactively #'org-timer-set-timer)))

(defun stefanv/org-log-pomodoro-duration ()
  "Logs the duration of the completed Pomodoro to the item where it was started."
  (let* ((end-time (current-time))
         (duration (float-time (time-subtract end-time stefanv/pomodoro-start-time)))
         (duration-mins (floor (/ duration 60)))
         (log-entry (format "- 🍅: %dm completed %s"
                      duration-mins
                      (format-time-string "%Y-%m-%d %H:%M" end-time))))

(defun stefanv/org-log-pomodoro-duration ()
  "Logs the duration of the completed Pomodoro to the item where it was started."
  (let* ((end-time (current-time))
         (duration (float-time (time-subtract end-time stefanv/pomodoro-start-time)))
         (duration-mins (floor (/ duration 60)))
         (log-entry (format "- 🍅: %dm completed %s"
                      duration-mins
                      (format-time-string "%Y-%m-%d %H:%M" end-time))))

    (when stefanv/pomodoro-start-time
      (org-with-point-at stefanv/pomodoro-start-mark
        (save-excursion
          (org-back-to-heading t)
          ;; Find LOGBOOK or create it after heading/meta-data
          (let ((drawer-regexp "^:LOGBOOK:")
                (subtree-end (save-excursion
                               (org-end-of-subtree t)
                               (point))))
            (if (re-search-forward drawer-regexp subtree-end t)
                ;; Drawer exists: insert after :LOGBOOK: line
                (progn
                  (forward-line 1)
                  (insert log-entry "\n"))
              ;; Drawer does not exist: create it after meta-data
              (org-end-of-meta-data)
              (insert (format ":LOGBOOK:\n%s\n:END:\n" log-entry)))))))
  ;; Cleanup
  (set-marker stefanv/pomodoro-start-mark nil)
  (setq stefanv/pomodoro-start-time nil)))

(add-hook 'org-timer-done-hook #'stefanv/org-log-pomodoro-duration)

org-mode is, to me, is one of the most valuable parts of the emacs ecosystem. I use it to take notes, plan projects, manage tasks, and write & publish documents.

Nowadays, a lot of work arrives via email, and so it is helpful to be able to refer to messages directly from my notes or lists of tasks.

The simplest option might be to store URLs pointing to an online inbox such as Fastmail or GMail, but I wanted a solution that was both future proof (i.e., what if I moved my emails to a different provider?) and worked with my terminal-based mail client of choice, neomutt.

I started with a solution provided by Stefano Zacchiroli, and simplified it for my specific use-case.

Overview #

The solution has two parts: sending email links from neomutt to Emacs, and later opening those links from Emacs by invoking neomutt. The first achieved via org-protocol, the latter via launching neomutt and then simulating keypresses.

When launching neomutt, we have to tell it in which directory the message lives. We therefore use notmuch to find the message file first, based on its Message-ID. maildir-utils would be another way of doing so. Please note that you have to have notmuch or maildir-utils set up already for this scheme to work.

I initially avoided the org-protocol package, because installation looked complicated. That, it turns out, is only the case if you care about web browser integration, which we don’t.

Neomutt configuration #

First, we have a Python script that can parse an e-mail and share the Message-ID and Subject with emacs. I call it mutt-save-org-link.py, and make it executable using chmod +x mutt-save-org-link.py.

#!/usr/bin/env python3

import sys
import email
import subprocess
import urllib.parse

# Parse the email from standard input
message_bytes = sys.stdin.buffer.read()
message = email.message_from_bytes(message_bytes)

# Grab the relevant message headers
message_id = urllib.parse.quote(message['message-id'][1:-1])
subject = message['subject']

# Ask emacsclient to save a link to the message
subprocess.Popen([
    'emacsclient',
    f'org-protocol://store-link?url=message://{message_id}&title={subject}'
])

We then configure neomutt (typically in ~/.muttrc) to call the script with a shortcut. I chose Esc-L (the same as Alt-L).

macro index,pager \el "|~/scripts/mutt-save-org-link.py\n"

Emacs configuration #

Using org-protocol, we instruct emacsclient to intercept URLs with the org-protocol:// scheme, as used by our mutt-save-org-link.py script. We also tell org-mode how to handle special URLs of the form message://message-id+goes_here@mail.gmail.com. Neomutt needs to know which Maildir folder to open, so we ask notmuch to tell us where the message is located.

In my ~/.emacs file I have:

; Make sure org-protocol is loaded
; Now, org-protocol:// schemas are intercepted.
(require org-protocol)

; Call this function, which spawns neomutt, whenever org-mode
; tries to open a link of the form message://message-id+goes_here@mail.gmail.com
(defun stefanv/mutt-open-message (message-id)
  "In neomutt, open the email with the the given Message-ID"
  (let*
      ((message-id (replace-regexp-in-string "^/*" "" message-id))
       (mail-file
        (replace-regexp-in-string
         "\n$" "" (shell-command-to-string
                   (format "notmuch search --output=files id:%s" message-id))))
       (mail-dir (replace-regexp-in-string "/\\(cur\\|new\\|tmp\\)/$" ""
                                           (file-name-directory mail-file)))
       (process-id (concat "neomutt-" message-id))
       (message-id-escaped (regexp-quote message-id))
       (mutt-keystrokes
        (format "l~i %s\n\n" (shell-quote-argument message-id-escaped)))
       (mutt-command (list "neomutt" "-R" "-f" mail-dir
                           "-e" (format "push '%s'" mutt-keystrokes))))

    (message "Launching neomutt for message %s" message-id)
    (call-process "setsid" nil nil
                   "-f" "gnome-terminal" "--window" "--"
                   "neomutt" "-R" "-f" mail-dir
                   "-e" (format "push '%s'" mutt-keystrokes))))

; Whenever org-mode sees a link starting with `message://`, it
; calls our `mutt-open-message` function
(org-add-link-type "message" 'stefanv/mutt-open-message)

There are a few caveats: if you use maildir-utils, the search command is mu find -f l i:%s instead of notmuch; and if you are not on Linux, then setsid (which we use to launch a detached background process) is not going to work, and you will want to use a different terminal emulator.

Other Systems #

Charl Botha mentioned in the comments that, on MacOS, org-mac-link lets you grab hyperlinks from a wide variety of apps. Email messages, specifically, are stored as message://message-id URLs, which MacOS knows how to open. This post has been updated to use the same link schema.

Wrap-up #

That’s it! I’ve added the code to https://github.com/stefanv/org-neomutt. Please file issues and PRs there, or tell me about your use cases in the comments below.

Since an org-mode buffer can be searched just like any other, I can simply invoke forward search with C-s, but this will match all occurrences of the text, instead of limiting the search to headings only.

This makes it hard to search for a phrase like “Travel”, for which I have a top-level heading, but also often occurs elsewhere in my notes.

I have a solution of the following form:

1. Launch a regular expression search
2. Pre-fill the text input with ^* so that only headings are matched.

First, define a custom search function. It puts the keys ^* in the “unread command events” list (i.e, a list of events waiting to be seen by emacs), and then launches interactive forward regular expression search.

(defun stefan/isearch-heading ()
  (interactive)
  (setq unread-command-events (listify-key-sequence "^* "))
  (isearch-mode t t nil t))

Next, we add a keybinding for org-mode:

(defun org-mode-keys ()
  (interactive)
  (local-set-key (kbd "C-c g") 'stefan/isearch-heading)
)
(add-hook 'org-mode-hook 'org-mode-keys)

And that’s it! Pressing C-c g (for “go”) in org-mode will now present you with a search prompt. Typing a heading name will take you there directly, at which point you can choose to expand it with the TAB key.

To install on Linux:

1. Grab the font.
2. Copy the files to ~/.fonts.
3. Run fc-cache -f -v.

The font should now be available for selection in apps such as Firefox, Gnome Terminal, etc. To make it the default font in Emacs::

    (set-default-font "Source Code Pro")

Here’s a comparison of Consolas (left) and Source Code Pro (right):

Comments also on Google+.

I recently tried to install MuMaMo as one of the dependencies for Takafumi Arakaki’s Emacs-based IPython notebook. The instructions on the MuMaMo webpage were as clear as mud and aimed primarily at Windows users. Enters apt-get for Emacs!

My Emacs setup is shared across multiple machines: a synchronized elisp folder, containing *.el files, along with my .emacs configuration. el-get allows you to share your package installation folder in a similar fashion. Here are some relevant configuration snippets:

; Everything gets installed into ~/elisp, a folder
; I sync across all my machines

(setq el-get-dir "~/elisp/el-get")
(setq el-get-install-dir "~/elisp/el-get/el-get")
(add-to-list 'load-path el-get-install-dir)

; If el-get is missing, install it automatically

(unless (require 'el-get nil t)
  (url-retrieve
   "https://raw.github.com/dimitri/el-get/master/el-get-install.el"
   (lambda (s)
     (goto-char (point-max))
     (eval-print-last-sexp))))

; Install these packages, and call the specified configuration snippets
; after each load
(setq el-get-sources
      '(

        (:name ethan-wspace
         :after (progn
                  (global-ethan-wspace-mode 1)
                  (set-face-background 'ethan-wspace-face "gray95")))

        (:name column-marker
         :after (add-hook 'font-lock-mode-hook
                          (lambda () (interactive) (column-marker-1 80))))

; Also install these packages, no configuration required
(setq my-packages
      (append
       '(el-get maxframe markdown-mode ein python)
       (mapcar 'el-get-source-name el-get-sources)
       )
)

; Check packages and install any that are missing
(el-get 'sync my-packages)

There are two ways to specify packages to be installed: either include them in the my-packages list, or add them to el-get-sources, which in addition allows further customization upon successful loading of the package.

What’s in your stack? Here’s my list of Emacs packages:

Org Mode, Ethan's wspace, Tab Bar, Column Marker, Max Frame, EIN, Python,
JS2

Do you know of any other useful packages? Let me know!