Elsa Gonsiorowski

Emacs Carnival: Org Mode Completions

gonsie@me.com (Elsa Gonsiorowski) — Sat, 28 Feb 2026 00:00:00 +0000

I’m so happy to be joining this month’s emacs carnival! I love the idea behind these carnivals and I think it’s such a good way of building community virtually.

This month’s topic is Emacs completions. I’m going to share a sort of “hack”… a way that I’ve been able to achieve completions within core org mode.

Org Mode Tempo Templates

Org Mode has long supported a template expansion mechanism, some times called “easy templates” or “structured templates”. The default behavior changed dramatically in version 9.2, and is now built on top of the Emacs builtin tempo.el.

Update To get the behavior described here, you must add (require 'org-tempo) to your config.

Essentially, you start a new line with <X (where X is a pre-defined key), then hit TAB to have the template expanded. For example, starting a new line with:

<s

and hitting TAB will expand to:

#+begin_src

#+end_src

Super handy and very easy to remember.

Default templates

The default are not entirely documented, though most are listed on the Structured Templates manual page.

Listed again here for convenience:

Key	Expansion
<a	`#+BEGIN_EXPORT ascii … #+END_EXPORT`
<c	`#+BEGIN_CENTER … #+END_CENTER`
<C	`#+BEGIN_COMMENT … #+END_COMMENT`
<e	`#+BEGIN_EXAMPLE … #+END_EXAMPLE`
<E	`#+BEGIN_EXPORT … #+END_EXPORT`
<h	`#+BEGIN_EXPORT html … #+END_EXPORT`
<l	`#+BEGIN_EXPORT latex … #+END_EXPORT`
<q	`#+BEGIN_QUOTE … #+END_QUOTE`
<s	`#+BEGIN_SRC … #+END_SRC`
<v	`#+BEGIN_VERSE … #+END_VERSE`

In addition to those blocks, there are also some quick tags:

Key	Expansion
<L	`#+latex:`
<H	`#+html:`
<A	`#+ascii:`
<i	`#+index:`
<I	`#+include:` (will interactively find file to include)

You can see that there is sort of a convention, uppercase letters usually insert a tag, whereas lowercase letters are mainly for blocks (though it’s definitely not perfect).

Additional Templates

Some additional templates can be defined by packages. For example, the org-re-reveal package adds:

Key	Expansion
<n	`#+begin_notes ... #+end_notes`

Basic Customization

You can add your own tags and blocks. In fact, there is actually no need for the “keys” to single characters.

Adding Tags

Adding another tag is very easy, seen here:

(add-to-list 'org-tempo-keywords-alist '("N" . "name"))

Which results in this completion:

Key	Expansion
<N	`#+name:`

Create a New Hotkey

I don’t like the <E hotkey for export block, instead I would like that to be <x. That is easily added with:

(add-to-list 'org-tempo-tags '("<x" . tempo-template-org-export))

Create a Completion

You can define your own completion with the tempo-define-template function (see the doc string for full details). It is very flexible! You can specify where the cursor (or “prompt”) ends up after the completion, or you can interactively prompt (via the minibuffer) for additional details. There are more advance features, including auto indentation and dealing with regions.

My Custom Completions

There is no requirement that these templates be simply blocks or tags. I’ve implemented about 5 custom templates, but here are a few that I think would be most useful for others.

Properties Drawer¹

Org headings can have properties, specified by the properties drawer:

:PROPERTIES:

:END:

I add this as <p via this implementation code:

(tempo-define-template "org-properties-block"
                       '(":PROPERTIES:" n
                         (p) n
                         ":END:" n %))
(add-to-list 'org-tempo-tags '("<p" . tempo-template-org-properties-block))

Title Block

This is one that I use most frequently. It’s a title block that I start all my org documents with. It also executes a function call to format-time-string to get today’s date in my preferred format. By having this completion, all of my org documents get a title with a date and I always know when I started working on a document!

My desired result:

#+title:
#+author: Elsa Gonsiorowski
#+date: February 28, 2026

The implementation code:

(tempo-define-template "org-title-block"
                       '("#+title: " (p) n
                         "#+author: Elsa Gonsiorowski" n
                         (concat "#+date: " (format-time-string "%B %e, %Y")) n %))
(add-to-list 'org-tempo-tags '("<t" . tempo-template-org-title-block))

I also implement another completion that is a slightly different title block which I use for starting all my blog posts. It includes the all the options that I want by default.

Finally

In writing this article I stumbled across orgmode documentation page for Completions. I had no idea these M-tab completions existed! (Clearly, since I implemented my own completion for the properties drawer). I’ll definitely be trying these out.

Footnotes

¹ The :properties: keyword can also be added with the M-tab completion on :

Sending Email from Org Mode

gonsie@me.com (Elsa Gonsiorowski) — Wed, 01 May 2019 00:00:00 +0000

Every so often, I need to generate a bunch of form emails. Often, I’m sending the same email to multiple groups of people and I want use variables, such as $first_name, in the text. While I’m sure there a number of online services which could achieve this for me, I really don’t need to set up a fancy campaign or use tracking. Plus, I’m wary of submitting others’ emails to a third party.

Of course, I’ve used Emacs to do this, using org mode and AppleScript.

Overview

To approach this task I start with a single org file. Getting AppleScript executing from an org block is trickier than I would like. Instead, I write the script whole cloth in my org file and tangle it out to a separate .scpt file. I store the data in my file as a table. I then use a bash block, which takes the data through :var, to loop over running the script.

AppleScript for Email

I’ve never formally learned AppleScript, but some searching on StackOverFlow and trial-and-error can get you pretty far. Mac OS X has a built in editor found in /Applications/Utilities/Script Editor. Once you’ve opened the editor, you can browse the dictionary with File > Open Dictionary.... This dictionary lists all the classes and commands for different applications. The AppleScript language itself looks like natural language and is relatively easy to understand… especially once someone else has properly constructed the program.

For my email-sender script, I store the AppleScript source is as a block. This block is tangled (C-c C-v C-t) to a .scpt file. The first half of this script sets some variables, including the body of the email message. The second half creates the message and sets a “to” recipient (could also set a “cc” recipient).

#+NAME: script
#+BEGIN_SRC apples :tangle email.scpt
on run argv
   set varName  to item 1 of argv
   set varEmail to item 2 of argv
   set varBody  to "Hello " & varName & ",

Blah blah blah. Lor ipsum, etc.

Sincerely,
Elsa"

   tell application "Mail"
        set theMessage to make new outgoing message with properties {subject: "Email", content: varBody, visible:true}
        tell theMessage
             make new to recipient with properties {name:varName, address:varEmail}
             #send
        end tell
   end tell
end run
#+END_SRC

Note that I’ve commented out the send command and set the message property visible: true. This means that the draft emails appear in the Mail GUI, but do not get automatically sent. This allows me to do trial runs before spamming my recipients.

Filling the Variables

Once I have the script and email body written, I know what variables I’ll need to fill in. The next step is to put all the data into a named org table. I usually do this data formatting by hand since I’m bringing together data items from many different sources.

#+NAME: data
|    Name    |      Email      |
|------------|-----------------|
| Mx. Person | person@test.com |

Since I tangle the email sending AppleScript program, I need to run it from the command line. I call the script once for each row in the data table using a bash loop and variable arrays. Then, I use C-c C-c to run the bash loop and generate the emails.

#+BEGIN_SRC bash :var name=data[,0] email=data[,1]
for i in `seq 0 0`; do
osascript email.scpt "${name[$i]}" "${email[$i]}"
done
#+END_SRC

Note that I do not calculate the total number of data items / rows. That would take way too much bash magic for this simple example. Also, if you want to test the variables with an echo statement, use :results output as an argument to the org block.

Hitting Send

I usually choose to manually hit send on each individual email once I’m satisfied with the script.

I keep all of these org commands in a single notes.org file so that I can remember how to recreate the emails (usually a year later when it’s time to send them again). For example, this notes.org file sends introduction emails for a mentoring program I organized with Women in HPC.