Erik L. Arneson — Writer and Software Developer

An Emacs Application Launcher for Regolith

2025-11-19T00:00:00+00:00

I run the Regolith Desktop Environment on my laptop, which I love because it provides a convenient GNOME wrapper and interface for the i3 tiling window manager. Regolith relies on a program called ilia for application launching, and sometimes ilia gets caught in some kind of CPU-churning state that locks up my whole system. I have not been able to figure out what is causing it, so I (of course) turned to Emacs for a solution.

Turning to `consult-omni`

Armin Darvish has created a powerful Emacs package called consult-omni, which provides a wrapper around consult for searching through any number of information sources. I believe consult-omni was originally intended to query web search engines and document databases, but Darvish has also provided a search mode for your local desktop applications, and can act as an application launcher.

Darvish provides an example application launcher in his consult-omni YouTube tutorial. The source code is straightforward, but I wanted to tweak it just a little. You can view his original on the project’s wiki on GitHub. You can watch him explain his technique below.

After a few tweaks, here is what I came up with.

(defun consult-launcher ()
  "A launcher suitable for use from a window manager."
  (interactive)
  (let* ((width (floor (* 0.6 (display-pixel-width))))
         (height (floor (* 0.6 (display-pixel-height))))
         (left (floor (* 0.2 (display-pixel-width))))
         (top (floor (* 0.2 (display-pixel-height))))
         (params `((name . "omni-launcher")
                   (width . ,(cons 'text-pixels width))
                   (height . ,(cons 'text-pixels height))
                   (left . ,left)
                   (top . ,top)
                   (minibuffer . only)))
         (frame (make-frame params)))
    (with-selected-frame frame
      (select-frame-set-input-focus frame)
      ;; If i3 is running and there is a control socket, let's tell
      ;; it we are a floating frame.
      (if (getenv "I3SOCK")
          (call-process "i3-msg" nil nil nil
                        (format "[id=%s] floating enable"
                                (s-trim (shell-command-to-string "xdotool getactivewindow")))))
      (unwind-protect
          (progn (consult-omni-apps-static ".*" (propertize "> " 'face 'consult-omni-path-face))
                 nil)
        (progn
          (when (frame-live-p frame) (delete-frame frame))
          nil)))))

I made two changes to get this to work nicely with i3. First, I removed the yequake dependency. Second, I added a call to i3-msg that sets the launcher frame as floating, which makes it much nicer to use. Like Darvish’s version, you can run this from the command line:

emacsclient -e '(consult-launcher)'

Adding an `ilia` fallback

Don’t tell all the other Emacs users, but I don’t have Emacs set up to launch automatically when I start my computer and log into X11. I probably should, huh? Also, there are times when I (gasp!) shut down Emacs, usually to restart it or fix something that I have broken. When those times happen, I want to be able to launch applications, so I need a failsafe in case consult-launcher isn’t available!

To solve this, I created a simple shell wrapper script, which looks like this:

#!/bin/bash

# Check if Emacs server is running by looking for the server socket
# Default server name is "server", but you can change this if needed
SERVER_NAME="${EMACS_SERVER_NAME:-server}"
SERVER_FILE="${XDG_RUNTIME_DIR:-/tmp}/emacs/${SERVER_NAME}"

if [ -S "$SERVER_FILE" ]; then
    # Emacs is running, use emacsclient to launch your application
    emacsclient -e '(consult-launcher)'
else
    # Emacs is not running, fall back to ilia
    ilia -p apps
fi

If you want to use this, the important part is that SERVER_FILE points to the socket that your Emacs server uses. Make sure that emacsclient and ilia are both in a reasonable location so your shell can find them, then bind this command to whatever you usually use to launch ilia.

By the way, if you are using Regolith’s normal method of launching ilia, you can add your shell script to your Regolith configuration pretty easily. Open $HOME/.config/regolith3/Xresources in your text editor, and add the line:

wm.program.launcher.app: /path/to/your/launcher.sh

You can then run xrdb -override $HOME/.config/regolith3/Xresources and it should work! Good luck.

Drawbacks

One of the nice things about ilia is that it keeps track of applications your run frequently, so they tend to bubble up to the top of its application listing. The Emacs method doesn’t do that. I don’t mind so much, I always end up typing in application names. It is fun to use Emacs as an application launcher, and I hope that it helps me avoid the CPU-churn problem that ilia has been experiencing far too often.

Have I come up with a clever solution, or a lazy workaround? I’m looking forward to hearing your thoughts.

Interviewed on "Prot Speaks"

2025-08-18T00:00:00+00:00

Well-known Emacs package creator Protesilaos Stavrou interviewed me for his video podcast series, “Prot Asks.” We talked about a wide variety of topics, from Emacs to podcasting to Portland to public transit. I thought it was a great time, and perhaps you will like it, too!

You can read and view the video on Prot’s website and blog, or you can go straight to YouTube, or you can watch it embedded here below.

Note that Prot is looking for people to talk to on this series! You can join in by signing up on his website.

P.S. In the video, I promised that I would do another Emacs Carnival blog post, and I will, I swear! It is in my org-mode to-do file.

Configuring Emacs 29.1 for Go Development

2023-08-01T00:00:00+00:00

Now that I have installed Emacs 29.1, I needed to get it set up for Go development for a project. I was interested in taking advantage of both the new Tree-Sitter integration, and the new Eglot language server client. However, they were mildly tricky to set up! Here is what I did.

Configuring Tree-Sitter for Go

If you follow the excellent How to Get Started with Tree-Sitter instructions from Mickey Peterson, you will have a great head-start on getting Tree-Sitter working for most of your favorite languages (and probably Java, too). However, those instructions didn’t cover everything I needed for Go. When I tried running M-x go-ts-mode, Emacs complained about a missing gomod module. Baffling!

I couldn’t find any information in the Emacs documentation about where to find this missing module. I looked around on the net and found Camden Cheek’s tree-sitter-go-mod, and added that to my list of recipes. My treesit-language-source-alist then looked like this:

(setq treesit-language-source-alist
 '((bash "https://github.com/tree-sitter/tree-sitter-bash")
   (cmake "https://github.com/uyha/tree-sitter-cmake")
   (css "https://github.com/tree-sitter/tree-sitter-css")
   (elisp "https://github.com/Wilfred/tree-sitter-elisp")
   (go "https://github.com/tree-sitter/tree-sitter-go")
   (gomod "https://github.com/camdencheek/tree-sitter-go-mod")
   (dockerfile "https://github.com/camdencheek/tree-sitter-dockerfile")
   (html "https://github.com/tree-sitter/tree-sitter-html")
   (javascript "https://github.com/tree-sitter/tree-sitter-javascript" "master" "src")
   (json "https://github.com/tree-sitter/tree-sitter-json")
   (make "https://github.com/alemuller/tree-sitter-make")
   (markdown "https://github.com/ikatyang/tree-sitter-markdown")
   (python "https://github.com/tree-sitter/tree-sitter-python")
   (toml "https://github.com/tree-sitter/tree-sitter-toml")
   (tsx "https://github.com/tree-sitter/tree-sitter-typescript" "master" "tsx/src")
   (typescript "https://github.com/tree-sitter/tree-sitter-typescript" "master" "typescript/src")
   (yaml "https://github.com/ikatyang/tree-sitter-yaml")))

Note that the package is named go-mod but go-ts-mode expects it to be named gomod. I wish this were documented somewhere! In any case, I was then able to use M-x treesit-install-language-grammar for both go and gomod. Finally, M-x go-ts-mode worked!

After going through this process, I found Robert Enzmann’s post about automatically using Tree-Sitter. He has created the treesit-auto package, now available on MELPA, that does most of this work for you. It is a much faster way of solving the gomod mystery, so give it a shot!

Configuring Eglot for Go

I’d been using lsp-mode for ages, but with Emacs 29.1 including Eglot, I decided to make the switch.

In my Go project, I ran M-x eglot and was immediately met with an error:

[eglot] Server reports (type=1): Error loading workspace folders (expected 1, got 0)
failed to load view for file:///path/to/my/project: err: go command required, not found: exec: "go": executable file not found in $PATH: stderr: 

I’ve got Go installed in /usr/local/go, and /usr/local/go/bin is definitely in my exec-path variable in Emacs. It looked like Eglot wasn’t propagating exec-path down to its subprocesses. How annoying! I did a quick search through the list of Eglot-related variables and the Eglot documentation and no solution seemed immediately forthcoming.

So I took the cheap way out and made a symlink. In my shell, I ran:

sudo ln -sf /usr/local/go/bin/go /usr/local/bin/go

It is a dumb trick, and I am sure there is a better way to solve it. Do you know of one? Please comment and let me know!

What Else?

My exploration has revealed that there’s a lot of work left to do in the Emacs Tree-Sitter world. There are plenty of languages major modes that don’t yet have a ts-mode equivalent, and plenty of others that still need a lot of work.

It’s too soon for me to say if this setup is preferrable to my previous configuration. But I am really looking forward to playing around with Eglot’s features and exploring the capabilities of Tree-Sitter.

Pattern Matching and Tail Recursion in Emacs Lisp

2022-11-19T00:00:00+00:00

Functional programming offers a bunch of really cool programming patterns. Two that I really enjoy are tail recursion and pattern matching, especially how they are implemented in OCaml. However, I spend a lot of time writing Emacs Lisp now, and I was wondering if I could find a way to use these patterns in that language.

It turns out that it is possible, thanks to named-let and pcase. It isn’t as pretty and elegant as OCaml, but at least I get to keep excercising those parts of my programming brain. Maybe next I’ll try to figure out currying in Emacs Lisp.

Note that this blog post includes some really dumb examples, because that’s usually how I learn these things best.

Pattern Matching with `pcase`

Most programmers will be familiar with the granddaddy of pattern matching, the switch/case construct. This is present in many, many programming languages, especially those in the ALGOL family.

However, pattern matching can be so much more! Instead of simple equality checks, pattern matching extends the switch/case concept to include testing for all kinds of patterns and conditionals.

Lisp programmers will already be familiar with cond, which can be used to sequentially test for conditionals. However, functional language programmers have probably fallen in love with a more mature and sophisticated form of pattern matching that cond doesn’t totally satisfy.

Fortunately, Emacs Lisp has pcase, the pattern-matching conditional. Here is an example of its use to duplicate car, which is the dumbest possible example I could think of.

(defun ela/car (lst)
  (pcase lst
    (`(,head . ,_)
     head)
    (_
     nil)))

You can see that pcase has a backquote syntax for matching various constructs, such as with the `(,head . ,_) piece. This matches a cons cell and binds the CAR to head while ignoring the CDR.

The next case is just _, which is a catch-all matching operator.

In the real world, you’d probably want some type checking and error correction, but I promised very simple examples. Check out the full range of matching capabilities for pcase, and then read about all of the backquote patterns you can also use.

Tail Call Optimization with `named-let`

Tail call optimization (TCO) is the programming language feature that allows efficient tail recursion without overflowing your stack. It is increasingly common in languages today, though from what I’ve seen, it always involves caveats.

In Emacs Lisp, the easiest way to use TCO that I’ve come across is the named-let macro. With it, you define a function that can get “unrolled” inside another function. For example, here is a simple function that calculates a factorial using tail recursion.

(defun ela/fact (in-num)
  (named-let rec-fact ((accu 1)
                       (num in-num))
    (pcase num
      ((guard (< 0 num))
       (rec-fact (* accu num) (- num 1)))
      (_
       accu))))

In this example, you will notice that rec-fact is the locally named function that gets called at the end of the first pcase pattern. This is a tail call! It will get optimized.

You can check this out by running something like (ela/fact 5) and getting 120 as the result. Try using a ridiculously big number and see if you get a stack overflow! You shouldn’t.

Another Example: Summing a List

This is just a nostalgic example, since it’s probably the first tail recursive pattern matching function I ever wrote when learning OCaml a zillion years ago. This function will take a list of numbers and then add them all together. There are much better ways to write this in Emacs Lisp, like with apply.

(defun ela/sum (numbers)
  (named-let sum-list ((accu 0)
                       (lst numbers))
    (pcase lst
      (`(,head . ,tail)
       (sum-list (+ accu head) tail))
      (_
       accu))))

You can then call it like this:

(ela/sum (list 1 2 3))

And you will end up with exactly the result you expect. I was amused to see that the documentation page for named-let has a different implementation of this function that doesn’t use pcase.

Oh heck, let’s get fancy and rewrite apply using this approach.

(defun ela/apply (fn &rest arguments)
  "Apply FN to each element of ARGUMENTS and return the accumulated result."
  ;; Set up accumulator to the right type.
  (let* ((arguments-flat (flatten-list arguments))
         (initial-value (pcase (car arguments-flat)
                          ((pred integerp) 0)
                          ((pred stringp) "")
                          (_ nil))))
    (named-let apply-rec ((accumulator initial-value)
                          (input-list arguments-flat))
      (pcase input-list
        (`(,head . ,tail)
         (apply-rec (funcall fn accumulator head) tail))
        (_
         accumulator)))))

I am certain this version of apply has bugs, but it works for + and concat, so that’s good enough for a simple example. And it uses pcase twice!

Hopefully this has been a useful blog post for somebody out there. Let me know in the comments if there are other fun things you have done with TCO and pattern matching in Emacs Lisp!

New MELPA Package: ddate

2022-11-01T00:00:00+00:00

I recently wrote an Emacs Lisp package to support the ddate command, a classic command-line utility to display dates from the Discordian calendar.

The package is now available on MELPA! That means that if you have use-package installed, you can get ddate easily like this:

(use-package ddate :ensure t)

Once you have the ddate package installed, you can use it to add the Discordian date to your dashboard with code like this:

(defun ela/dashboard-insert-ddate (list-size)
  "Insert the Discordian date into the dashboard."
  (let ((ddate-string (ddate-pretty)))
    (dashboard-center-line ddate-string)
    (insert ddate-string)))

(use-package dashboard
  :init (dashboard-setup-startup-hook)
  :config
  ;; Add the ddate item provider to the list.
  (add-to-list 'dashboard-item-generators
               '(ddate . ela/dashboard-insert-ddate))

  ;; Set up your items with ddate at the top.
  (setq dashboard-items '((ddate)
                          (recents   . 5)
                          (bookmarks . 5)
                          (registers . 5))))

You can view the source code for ddate on Sourcehut.

Yasnippet and Emacs for Writing

2022-09-28T00:00:00+00:00

As a freelance writer, I need to be ready to deliver high quality copy in a timely fashion. My editor of choice for writing is Emacs. I have found that Yasnippet templates have streamlined my writing process.

What is Yasnippet?
Installing Yasnippet
Markdown and Jekyll
- Bonus Snippets
Org Mode Templates
- org2blog and Podcast Show Notes
- More Bonus Snippets
Writing Faster is Writing Smarter

What is Yasnippet?

As a templating system for Emacs, Yasnippet is well known by programmers. It can quickly expand function definitions, control structures, and other templates into blocks of source code. Source code is just text.

Since most of my writing originates in text format, templates are great for speeding up document creation and avoiding common errors and omissions.

Installing Yasnippet

With use-package, you can get started quickly with Yasnippet by including the following in your Emacs init file.

(use-package yasnippet
  :ensure t
  :config
  (yas-global-mode 1))

(use-package yasnippet-snippets
  :ensure t
  :after yasnippet)

For more detailed installation instructions, check the Yasnippet documentation.

Markdown and Jekyll

This blog is primarily written in Markdown for Jekyll, which means that each file needs a YAML block at the top with specific information. I have a template that looks like this:

# -*- mode: snippet -*-
# name: blogtop
# key: blogtop
# --
---
title: ${1:Title}
author: "Erik L. Arneson"
layout: post
permalink: `(format-time-string "/%Y/%m/")`$2
comments: ${3:$$(yas-choose-value '("true" "false"))}
tags:
    - $4
---

$0
<!--more-->

Not only does this template save me from needing to remember the format of the YAML block, but it ensures that frequently forgetten items are included, such as the permalink setting and the  tag.

Bonus Snippets

The official snippet collection contains a bunch of extra Markdown templates. Check them out here.

Org Mode Templates

My Org Mode files are more complex. Many writing clients expect deliveries in Microsoft Word files, but I also frequently find myself needing to produce OpenDocument files, HTML, and even Markdown. The headers for these files need to support all of these options.

I use the following template to support all of the Org Mode configuration and options I require.

# -*- mode: snippet -*-
# name: header
# key: header
# --
#+TITLE: $1
#+LANGUAGE: ${2:en}
#+AUTHOR: ${3:$$(yas/choose-value '("Erik L. Arneson" "Some Other Name"))}
#+EMAIL: ${4:$$(yas/choose-value '("list-of-email-addresses"))}${5:
#+DESCRIPTION: $6}${7:
#+KEYWORDS: $8}
#+OPTIONS: num:nil toc:nil
#+ODT_STYLES_FILE: ${9:$$(yas/choose-value '("list-of-template-files"))}
#+bibliography: /path/to/MyLibrary.bib
#+cite_export: csl ${10:$$(yas/choose-value '("chicago-fullnote-bibliography.csl" "modern-language-association.csl" "apa.csl"))}
#+WWG: ${11:$$(yas/choose-value '("0" "250" "500" "1000"))}

$0

org2blog and Podcast Show Notes

I also use Org Mode to publish to WordPress websites using org2blog. For one of these websites, I write show notes for podcast episodes. I use a template that looks like this.

# -*- mode: snippet -*-
# name: podcast
# key: podcast
# --
* $1
  :PROPERTIES:
  :POST_TAGS: $2
  :BLOG:      arnemancy
  :CATEGORY:  Podcast
  :POST_DATE: `(format-time-string "[%Y-%m-%d %a %H:%M]" nil nil)`
  :END:

$0

** Links

** Credits

#+begin_export html
Support me on Patreon: <a rel="payment" href="https://www.patreon.com/arnemancy">https://www.patreon.com/arnemancy</a><br>
#+end_export

This template reminds me of important items I need to include in all show notes, like links, credits, and a Patreon link.

More Bonus Snippets

The official snippet collection also contains a bunch of Org Mode snippets. Here is the whole list. Since Org Mode contains so many complicated structures like source blocks and optional keywords, these are great time savers. There are also snippets for supporting org-reveal.

Writing Faster is Writing Smarter

Don’t let your tools get in the way of your writing. Frequently, Emacs is portrayed as cumbersome and filled with obscure keybindings and weird commands. However, I have found that it is an excellent tool for writing. Yasnippet templates let me get started on new documents quickly without fretting over different syntaxes for configuration.

And Yasnippet is just one of the tools I use when writing with Emacs. I will discuss more of these tools in the future.

Typing Chinuk Wawa in Emacs

2021-10-11T17:01:00+00:00

Back in 2015, I took a course in being an ally for local Native American communities from the Portland Underground Grad School (PUGS). One suggested action was learning the local language, but it proved difficult to find opportunities. When the pandemic forced school closures, though, Lane Community College began offering classes online. I found out about this thanks to the Kaltash Wawa blog, and this fall I signed up to take a remote Chinuk Wawa class through Lane Community College.

What is Chinuk Wawa?

Chinuk Wawa originated as a type of creole or pidgin trade language in the Pacific Northwest, incorporating loan words from more than a dozen indigenous and European languages. Though it has a small lexicon, it is an interesting language with an impressive array of new phonemes for me to learn. There are 12 different variations on “k”, for instance! As you can imagine, with this variety, it is pretty difficult to type Chinuk Wawa using the standard Latin alphabet. I am learning the Grand Ronde dialect, which uses an IPA-based alphabet.

Keyman for Linux

Under Linux, the easiest way to add an IPA-based input method is using the IPA (SIL) keyboard for Keyman. This integrates nicely under GNOME 3 with Ubuntu 20.04. However, I’m a Dvorak typist, so having to switch back to a QWERTY-style keyboard is frustrating, and was slowing me down. Instead, I came up with this method for inputing Chinuk Wawa compatible IPA using Emacs.

Emacs Input Methods

Emacs has an easy method for switching between input methods, which you can read more about in the Emacs manual. It comes with a number of IPA input methods, and after taking a look at all of them, I chose ipa-x-sampa, as it seemed to have the best coverage of symbols needed by Chinuk Wawa. However, it was missing a way to input the character “x̣”, which was needed by one of the first words I learned, “yax̣al”!

I added the following code to my startup file to remedy this. This adds the ability to type x_. to get x̣ and ?/ to get ?, both of which make typing Chinuk Wawa much easier for me.

(defun chinuk-wawa-quail-rules ()
  "Add Chinuk Wawa rules to the `ipa-x-sampa` input map."
  (interactive)
  (if (string-equal "ipa-x-sampa" (quail-name))
      (quail-define-rules
       ((append . t))
       ("_." #x0323)   ;; allows for x with dot beneath
       ("?/" "?"))     ;; allows for ? character 
    ))

(add-hook 'quail-activate-hook 'chinuk-wawa-quail-rules)

As you can see, this method allows plenty of additional characters to be added to ipa-x-sampa, so if it turns out I missed anything, I can expand on it later.

The biggest downside of this is that I can only input Chinuk Wawa easily in Emacs, but since I do most of my work there—including writing this blog post—it doesn’t feel that bad to me. It’s definitely better than typing QWERTY!

aɬqi!