Flaky Goodness

Building Emacs 30 on macOS

Wed, 10 Dec 2025 00:00:00 -0500

December 10, 2025

This is an update to my post about compiling Emacs 29.4 from source. Emacs has been moving forward but unfortunately my beloved Mitsuharu Emacs Mac Port has not. Happily JD Smith has picked up the mantle and there is an up-to-date (albeit experimental) Emacs 30 fork on GitHub. This post documents the steps I took to build Emacs 30.2 on my M3 MacBook Pro.

Remove existing Emacs

Backup and delete /Applications/Emacs.app if you have one. I highly encourage you to keep a backup of your old Emacs around for a while in case you hit any snags building the new one.

Update Xcode command-line tools

Don’t skip this step of reinstalling the latest version of the tools. You’ll need to install Xcode first if you don’t already have it. I was using Xcode 16.4 when I went through this process.

sudo rm -rf /Library/Developer/CommandLineTools
xcode-select --install

Install/re-install dependencies

brew update
brew reinstall gcc
brew install libgccjit pkgconf texinfo tree-sitter

Get a fresh clone of Emacs

The only branch I was able to successfully build was emacs-mac-30.2, but that might have changed by the time you read this.

git clone https://github.com/jdtsmith/emacs-mac
cd emacs-mac
git checkout emacs-mac-30.2

Configure and make

I used the self-contained configuration and followed the instructions in the README.md on the GitHub page.

./autogen.sh

CFLAGS="-O2 -mcpu=native" ./configure --with-native-compilation \
  --with-tree-sitter \
  --with-xwidgets \
  --enable-mac-app=yes \
  --enable-mac-self-contained

make -j6

make install

I am so happy that this project has found new life and that this flavor of Emacs will continue to be available for Mac users.

UPDATE 2025-12-18 removed jansson since JSON support is baked into Emacs 30. Thanks to @genehack for pointing this out!

Emacs ibuffer live update

Sun, 14 Sep 2025 00:00:00 -0400

September 14, 2025

Inspired by a a recent post by The Emacs Cat about their ibuffer configuration, I was wondering why the ibuffer didn’t update live as buffers were created and killed. With some help from Prot here is a way to hook into the relevant function in Emacs to update the ibuffer list any time the list of buffers changes. The real-time feedback makes managing a large number of buffers more pleasant.

This code sets a timer to start every time the buffer-list is updated. The timer is debounced, so that it only fires once even if a number of buffers are updated one after another. When the timer fires, any ibuffer that is currently open gets refreshed. Very nice.

(defvar my/ibuffer-refresh-timer nil
  "Debounce timer for ibuffer refreshes triggered by buffer list changes.")

(defun my/ibuffer-refresh-start-timer ()
  (when my/ibuffer-refresh-timer
    (cancel-timer my/ibuffer-refresh-timer))
  (setq my/ibuffer-refresh-timer (run-at-time 0.2 nil #'my/ibuffer-refresh)))

(defun my/ibuffer-refresh ()
  (setq my/ibuffer-refresh-timer nil)
  (when-let ((buffers (seq-filter
                       (lambda (buf)
                         (with-current-buffer buf
                           (derived-mode-p 'ibuffer-mode)))
                       (buffer-list))))

    (dolist (buf buffers)
      (with-current-buffer buf
        (ibuffer-update nil :silent)))))

(add-hook 'buffer-list-update-hook #'my/ibuffer-refresh-start-timer)

Quickly summing up the whole stack in Emacs Calc

Sun, 02 Feb 2025 00:00:00 -0500

February 2, 2025

Here is a nice little improvement to calc-mode that adds up all the numbers on the stack. It’s equivalent to hitting the + key until the stack is exhausted, and it’s more handy than I would have expected.

(defun my/calc-sum-stack ()
  (interactive)
  (when-let* ((stack calc-stack)
              (additions (- (length stack) 2))
              (_ (> additions 0)))
    (dotimes (i additions) (call-interactively 'calc-plus))))

I’ve bound it to Ctrl + like this:

(with-eval-after-load 'calc
  (define-key calc-mode-map (kbd "C-+") #'my/calc-sum-stack))

Speeding up Emacs Lisp functions by disabling garbage collection

Wed, 28 Aug 2024 00:00:00 -0400

August 28, 2024

Emacs Lisp has nice built-in profiling tools but if you’re just curious to see how long a function takes to run, you can call it from inside benchmark-run:

(benchmark-run (my-slow-function))

This will output a list with three elements. The first is total runtime in seconds. The second element is the number of garbage collections required during execution, and finally the time used by the garbage collector.

For example, I can see how long it takes to export my static blog site as follows:

(benchmark-run (export-my-blog))

(7.007418 45 3.120531000000028)

It is taking 7 seconds total of which 3 seconds are consumed by 45 garbage collection passes.

Can we save some time by opting out of garbage collection during this process?

Here is a wrapper function that temporarily disables garbage collection while an arbitrary function is called. We do this by increasing the garbage collection threshold to a very large number.

(defun without-gc (&rest args)
  (let ((gc-cons-threshold most-positive-fixnum))
    (apply args)))

Now we can call:

(benchmark-run (without-gc #'export-my-blog))

(4.881724999999999 1 1.7296989999999823)

Down to 4.9 seconds, only 1.7 of which are used by a single garbage collection pass (presumably at the end of execution).

It is worth noting that opting out of garbage collection might not make sense for extremely long running or memory intensive processes: you don’t want Emacs to accidentally gobble up all of your available memory. Still, this is a nice optimization for those Emacs operations that seem to drag on just a bit too long.

Failing to share the benefits of using Emacs

Mon, 19 Aug 2024 00:00:00 -0400

August 19, 2024

I’ve become self-conscious about proselyting Emacs to my friends and in public spaces. As enthusiastic as I am about Emacs, I find it difficult to convince others to invest in the learning process. And it is undeniably an investment. I limit my pitch attempts to already technical people that I think could benefit and (more importantly) would enjoy the same things many of us do about Emacs. My arguments tend to get dismissed, however, and I’ve been trying to understand why.

This has been observed before, but I particularly like the way Prot said it a few months ago:

The skills you acquire as you gain more experience with Emacs have a compounding effect. You eventually get more out of the time you invest in them, which practically means that you are empowered to design the workflow you want …

It strikes me how unusual this compounding effect is among our software tools. As technical professionals we tend to look for the best tool for the job until the tool changes or the job changes, and don’t think much of either when we move beyond it. We’re vocationally accustomed to, perhaps optimized for, having our technology stack swap itself out every few years and have trained ourselves out of committing too deeply to anything in the stack. Ultimately that commitment has an expiration date.

I don’t think most people fully understand that the compounding returns of an investment in Emacs is a lifetime benefit. That Emacs might be the one piece of software we use that could outlive us. And when I try to make that argument to my Obsidian / VS Code / JetBrains using friends you should see the looks I get.

Upgrading to Emacs 29.4 on Apple Silicon Macs

Sat, 17 Aug 2024 00:00:00 -0400

August 17, 2024

This is an update to my post about compiling Emacs 29.1 from source. Probably due to shifting dependencies that procedure no longer seems to work for me in Sonoma 14.6.1, and there have also been some important security fixes to Emacs and Org Mode that make it advantageous to update as soon as possible.

Unfortunately the Mitsuharu Emacs Mac Port has not yet been tagged and released for any version past 29.1. Happily, the work branch has been updated to 29.4 and this is what I’m using to write this post. Because this isn’t an officially tagged release, I am expecting that there might be issues down the road but it seems to be working well so far.

Remove existing Emacs

Backup and delete /Applications/Emacs.app if you have one. I highly encourage you to keep a backup of your old Emacs around for a while in case you hit any snags building the new one.

Update Xcode command-line tools

Don’t skip this step of reinstalling the latest version of the tools. I suspect you’ll need to install Xcode first if you don’t already have it. I am currently using Xcode 15.4.

sudo rm -rf /Library/Developer/CommandLineTools
xcode-select --install

Install/re-install dependencies

brew update
brew reinstall gcc
brew install libgccjit texinfo tree-sitter jansson

Get a fresh clone of Emacs

Currently the work branch is the one with Emacs 29.4. Hopefully there will be a tagged release soon.

git clone https://bitbucket.org/mituharu/emacs-mac
cd emacs-mac
git checkout work

Configure and make

autoreconf -i

./configure \ 
  --with-native-compilation \ 
  --with-modules \ 
  --enable-mac-app \ 
  --with-xwidgets \ 
  --with-tree-sitter \ 
  --prefix=/Applications/Emacs.app/Contents/Resources
    
make

Add additional required resources

The build process leaves out some required lisp resources, which you will discover if you try to launch the Emacs.app bundle from Finder or from console by typing:

mac/Emacs.app/Contents/MacOS/Emacs

You can manually move these required files into the bundle with:

mkdir -p mac/Emacs.app/Contents/Resources/share/emacs/29.4
mv lisp mac/Emacs.app/Contents/Resources/share/emacs/29.4
mv etc mac/Emacs.app/Contents/Resources/share/emacs/29.4
mv native-lisp mac/Emacs.app/Contents

Move the built Emacs.app into /Applications

Drag Emacs.app into your Applications folder and you should be ready to go. Remember that Emacs will be slow for a while after first launch as native compilation makes its way through all the Emacs Lisp sources packaged with Emacs.

UPDATE 2024-08-18 to move the etc folder (with documentation) into the app bundle

Always Yes in Emacs Lisp

Sun, 09 Jun 2024 00:00:00 -0400

June 9, 2024

Some Emacs commands tend to ask too many confirmation questions, or at least it would be nice to have the option to skip the confirmation step. For example, saving and quitting a merge session in ediff requires quitting, confirming the quit, and then confirming the save.

I wanted to bind a single keystroke that would unconditionally commit my changes and end ediff. In the process, with the help of a coaching session from Prot, I made a general-purpose wrapper around any Emacs function to bypass confirmation.

(defun always-yes (&rest args)
  (cl-letf (((symbol-function 'yes-or-no-p) #'always)
            ((symbol-function 'y-or-n-p) #'always))
    (funcall-interactively (car args) (cdr args))))

I then used it to bind Q to unconditionally quit ediff, which requires a little more work than other packages typically would:

(defun my/ediff-quit-unconditionally ()
  (interactive)
  (always-yes #'ediff-quit))

(defun add-Q-to-ediff-mode-map () (define-key ediff-mode-map "Q" 'my/ediff-quit-unconditionally))
(add-hook 'ediff-keymap-setup-hook 'add-Q-to-ediff-mode-map)

This is a small improvement to be sure, but little quality of life improvements like this accrue over time. It’s one of the things I like most about Emacs.

Printing PostScript from Emacs in macOS Sonoma

Sat, 23 Dec 2023 00:00:00 -0500

December 23, 2023

Apple removed support for PostScript in macOS Sonoma, which has broken a number of things in my daily workflow. Here is a quick roundup post of some of my workarounds.

Install Ghostscript with Homebrew

First, install Homebrew if you don’t already have it.

Now, install the Ghostscript PostScript interpreter:

brew install ghostscript

To confirm that it has installed correctly, open a Terminal and type:

gs --version

You should see something like 10.02.1.

manp script for nicer man pages in Preview

I have added this to my .zshrc but it should work just as well in .bash_profile and similar.

function manp() {
  [ -n "$1" ] && man -t $1 | gs -sDEVICE=pdfwrite -o $TMPDIR/$1.pdf - && open $TMPDIR/$1.pdf && sleep 1 && rm $TMPDIR/$1.pdf
}

Now you can type manp instead of man to view your man pages as a nicely formatted PDF in Preview.

Emacs PostScript Print Buffer / Region

Emacs depends on the system lpr utility to print PostScript and as of macOS Sonoma, lpr no longer supports PostScript. The specific error message you will see is:

user-error: Spooling...done: /usr/bin/lpr: Unsupported document-format “application/postscript”.

Let’s create our own lpr alternative for Emacs to use.

In a convenient executable folder (in my case, /Users/gene/bin), create the following file and call it lpr-ps

#!/bin/bash
uuid=$(uuidgen) gs -sDEVICE=pdfwrite -o $TMPDIR/$uuid.pdf - && open $TMPDIR/$uuid.pdf && sleep 1 && rm $TMPDIR/$uuid.pdf

Make it executable:

chmod +x /Users/gene/bin/lpr-ps

Add the following to your Emacs configuration (with your particular path of course):

(setq ps-lpr-command "/Users/gene/bin/lpr-ps")

PostScript Print Buffer and PostScript Print Region (M-x ps-print-buffer and M-x ps-print-region) should now open a nicely formatted Preview document for you.

NOTE: if you are getting an error like The file … couldn’t be opened because there is no such file. Try changing sleep 1 to a bigger number of seconds, like sleep 10 or even sleep 30. The script tries to delete the generated temporary file as soon as possible, but sometimes this is sooner than Preview can get it onto the screen. Keep bumping this number up until the script is reliable for you. The tradeoff is that control isn’t returned to Emacs until the full sleep timeout has elapsed.

Emacs Org LaTeX export to PDF

This might not be an issue for you, but if you use Org’s export to PDF via LaTeX I had to make the following additional change to my Emacs config. Something about pdflatex not being a known LaTeX compiler.

(setq org-latex-pdf-process '("latexmk -f -pdf -interaction=nonstopmode -output-directory=%o %f"))

I’ll continue updating this post with additional PostScript-on-Mac workarounds as I find and implement them.

Upgrading to Emacs 29.1 on Apple Silicon Macs

Sun, 13 Aug 2023 00:00:00 -0400

August 13, 2023

This is an update to my post about compiling Emacs 28.1 from source. With the recent release of Emacs 29.1, here are the steps I used to upgrade.

Remove existing Emacs

Backup and delete /Applications/Emacs.app if you have one.

Install/re-install dependencies

brew update
brew reinstall gcc
brew install libgccjit texinfo tree-sitter jansson
sudo rm -rf /Library/Developer/CommandLineTools
xcode-select --install

It still seems to be necessary to re-install Xcode command-line tools to prevent Emacs from getting killed on launch.

Get a fresh clone of Emacs

I don’t tend to remote into my Emacs session any more so I didn’t bother updating or applying the multi-tty patch. I may reconsider that if my needs change in the future.

git clone https://bitbucket.org/mituharu/emacs-mac
cd emacs-mac
git checkout emacs-29.1-mac-10.0

Configure and make

autoreconf -i

./configure \ 
  --with-native-compilation \ 
  --with-modules \ 
  --enable-mac-app \ 
  --with-xwidgets \ 
  --with-tree-sitter \ 
  --prefix=/Applications/Emacs.app/Contents/Resources
    
make

Add additional required resources

The build process seems to leave out some required lisp resources, which you will discover if you try to launch the Emacs.app bundle from Finder or from console by typing:

mac/Emacs.app/Contents/MacOS/Emacs

You can manually move these required files into the bundle with:

mkdir -p mac/Emacs.app/Contents/Resources/share/emacs/29.1
mv lisp mac/Emacs.app/Contents/Resources/share/emacs/29.1
mv lative-lisp mac/Emacs.app/Contents

Move the built Emacs into /Applications

I didn’t have much luck with make install so I just manually moved emacs-mac/mac/Emacs.app into /Applications

This was pretty smooth for me, probably because I had things nicely wired up from my previous installation. Good luck!

UPDATE 2023-10-02 to add --with-tree-sitter configuration option and manual installation process. UPDATE 2024-08-17 to add additional required resources to prevent Emacs from being killed at launch

Upgrading to Emacs 28.1 on Apple Silicon (M1) Macs

Sun, 10 Apr 2022 00:00:00 -0400

April 10, 2022

This is an update of sorts to my previous Emacs build recipe and late-night Emacs-on-M1 twitter thread.

The Emacs Mac Port has been updated for Emacs 28.1 and here are the steps I used to build and install it on my M1 MacBook Air. Overall the process seems much smoother than the pre-release build experience but as always YMMV.

Install/re-install dependencies

brew reinstall gcc
brew install libgccjit texinfo
brew ln texinfo --force

I’m not sure why it was necessary to reinstall gcc (maybe an architecture issue?), but it seemed to help with a build error in a subsequent step. Also texinfo provides an updated makeinfo which is now no longer optional in the Emacs build process.

Add makeinfo to path

Add this to your shell path (necessary so that the makeinfo provided by texinfo is seen before the older macOS-provided version).

/opt/homebrew/opt/texinfo/bin

Install/re-install Xcode command-line tools

sudo rm -rf /Library/Developer/CommandLineTools
xcode-select --install

Again, something was wedged in the subsequent build process until I took this step, as recommeded in this GitHub thread.

Clone Emacs

These steps also apply the (optional) multi-tty patch that I’ve written about before.

git clone https://bitbucket.org/mituharu/emacs-mac
cd emacs-mac git
checkout emacs-28.1-mac-9.0
autoreconf -i
wget https://gist.github.com/genegoykhman/6effe7fa25696c49d0519af877f5fb42/raw -O multi-tty.patch
git apply multi-tty.patch

Configure and build

./configure \
  --with-native-compilation \
  --with-modules \
  --enable-mac-app \
  --prefix=/Applications/Emacs.app/Contents/Resources

make install

Confirm your emacsclient is linked to the right place

The above steps will update your /Applications/Emacs.app in place, so if you had emacsclient in a different subdirectory (as I did) you may want to replace any symbolic links to the newly build version at /Applications/Emacs.app/Contents/Resources/bin/emacsclient.

Starting Emacs

If all goes well you should be able to start Emacs and (emacs-version) will report 28.1. The new native-compilation feature will churn through your startup Elisp and probably spew a ton of warnings, but eventually you’ll notice that Emacs feels much zippier.

If you don’t see any (comp) warnings on first startup you might just want to check that native compilation is working … (fboundp 'native-compile-async) should return t.