A few weeks ago, Bozhidar Batsov had a splendid post on cl-flet, cl-letf, and cl-labels. I didn’t get a chance to write about it then but his post is very useful for understanding these macros and how they differ.

The macros are the replacements for the now deprecated flet, which, in turn, was imported from Common Lisp with the added feature of having dynamic scope. As Batsov points out, making the scope dynamic conflates the notion of local and dynamic scope, which can be a bit confusing. This behavior is preserved by the cl-letf macro for those who need it.

The cl-flet macro is just like the flet macro from Common Lisp. It defines a local function whose definition is available only from within its scope. The salient fact is that its definition is not available from within the function definition so it can’t be called recursively.

The cl-labels macro is like labels from Common Lisp. It’s similar to cl-flet except that its definition is available from within the function definition so it is recursive.

Finally, the cl-letf macro largely replicates the behavior of the old (Elisp) flet macro with the addition that it can dynamically replace the definition of any setf-able definition. This can complicate its use a bit. See Batsov’s post for the details.

If you’re like me, you don’t use any of these macros that often so it’s easy to forget the details. For that reason it’s worthwhile bookmarking Batsov’s post so that you can refresh your memory whenever you need to.

This post is simply about some more yak shaving and there was this one niggle that I just kept putting off, because it never really annoyed me enough, but recently I started watching a lot more video content from within dired and it finally got to me.

The problem. I press W in dired, which is bound to dired-do-async-shell-command, type mpv (or accept the default guess that my dired-guess-shell-alist-user provides for video files), and the video starts playing. Great. But when I close Emacs, the video dies too. The whole point of an async command is that it runs in the background, right?, so why does it disappear when Emacs goes away?, this is most perplexing!

Now I should say, the answer is obvious in retrospect, but it took me a little while to actually stop and think about it properly. The command dired-do-async-shell-command adds a trailing & to the shell command and passes it to async-shell-command, which creates a shell process - Emacs is the parent of that shell, and the shell is the parent of mpv. When Emacs exits, it kills its child processes, the shell goes down, and mpv gets orphaned, which is fine actually, the problem is not being orphaned, the problem is that it receives a SIGHUP from the process group cleanup and dies before it can be reparented to init. So the media stops.

The solution is a single, tiny piece of advice. I just prepend nohup to the command string before dired-do-async-shell-command does anything with it. nohup makes the process ignore SIGHUP, so when the shell gets killed by Emacs, mpv is orphaned cleanly and keeps running.

(defun my/dired-async-shell-command-nohup (orig-fun command &optional arg file-list)
  "Wrap COMMAND with `nohup' so the process survives Emacs exit."
  (funcall orig-fun (concat "nohup " command) arg file-list))

(with-eval-after-load 'dired
  (advice-add 'dired-do-async-shell-command
              :around #'my/dired-async-shell-command-nohup))

That is it. Six lines of Elisp, five of which are boilerplate.

And yes, this works for any command you run through W, not just mpv. gimp, firefox, libreoffice - they all get the nohup treatment now. Which is fine, those programs usually detach themselves anyway, but it does not hurt to have it.

So that is the tweak. A tiny, one-function, one-advice change that finally stopped my videos from dying every time I closed Emacs. I suspect someone will tell me that there is a simply variable flag that I can set that enables this anyway, but hey ho!

Keyboard Commands

I ran out of keyboard commands.

OK, that sounds weird. Let me explain. In Alfred, I have the following keyboard assignments:

⇧⌃A: App Store
⇧⌃B: BBEdit
⇧⌃E: Emacs

I had covered the alphabet. Every letter had an application associated with it. I started a second layer. I assigned ⇧⌃⌥B to Better Finder Rename, ⇧⌃⌥E to EagleFiler and so on. Soon I was running out of choices again.

Over a period of almost 15 years, I made do. I loved Alfred, I also loved keyboard commands. I wanted to be able type a keyboard command and then choose from a list of applications which were tied to that keyboard command. I wanted to be able to type something small to be able to navigate this list and launch the application I wanted.

I didn’t know how to do this in Alfred. I had hacked together a solution in Keyboard Maestro, but I wanted to do it in Alfred. It was my launcher. So, I went to the Community for Alfred and asked, Choosing to launch particular programs with a shortcut - Workflow Help & Questions - Alfred App Community Forum. FireFingers21 answered with a workflow.

FireFingers21’s solution had two parts:

1. The ability to assign a keyboard command to a workflow which would give me a list of applications assigned to it. I could press the keyboard command and then choose from a list by typing the number corresponding to my choice. Hit ↵ to launch.
2. The ability to assign a keyboard command to a workflow which presented a similar list. This time the list could contain multiple applications grouped together.

This Is How It Helped

Outliners

Previously, I had ⇧⌃O assigned to open OmniOutliner. The same command now gives me the ability to launch OmniOutliner, Zavala, or Opal, depending on my needs. This is now the Outliner keyboard command.

Editors

⇧⌃E, opened Emacs. Not anymore, now it can open any of these programs. Don’t laugh. I am aware that I have too many editors installed.

Multi

I have Hyper-A assigned to multi-application launches. Every morning I used to start my workday by pressing Hyper-A and that would launch:

1. SpamSieve
2. Mail
3. Safari
4. Ghostty

Now it gives me a choice. I can also launch my updates group:

1. Applite
2. Mac App store
3. Latest
4. Wailbrew

One keyboard command, groups of multiple applications launched together.

Conclusion

1. I have keyboard commands to spare.
2. Alfred is a great product. I knew that.
3. The community around Alfred are helpful and informative.
4. Don’t hesitate to ask questions when you don’t know how to do something. There are helpful people around who might have the answers and they are willing and ready to help you.
5. Thanks to FireFingers21 and Vero for their help.

Note: Thanks to Darren Halos for the picture.

macosxguru at the gmail thingie.

Charles Choi is back with more menus. Most of you know that I generally eschew the use of Emacs menus but they definitely have a place in seldom used commands whose name or key shortcut are hard to remember. In most cases, it’s possible to play around with fuzzy command completion and find what you’re looking for but it’s a lot easier to simply use a menu if it’s there.

That’s where Choi’s latest update to Anju comes in. He says that the introduction of context-menu-mode in Emacs 28 made it possible to provide cotentxt sensitive menus for Elisp development and he has added it to the latest version of Anju.

His post has a couple of screen shots of his menus in action. In the first, the point is on a function definition and the menu, among other things, offers the choice to instrument that function. In the second, the function has been instrumented and now the (context sensitive) menu offers things you can do—such as step into, set a breakpoint, and others—with the function. Naturally all of this is dependent on where the point is. That’s the point: the menu is context sensitive.

Choi says that the use of the context menus has markedly improved his Elisp development. If you do some but not a lot of Emacs development, it may be a win for you. On the other hand, Choi certainly does do a lot of Emacs development and still finds it a win. Perhaps—no matter your normal workflow—you will too.

For ages I’ve had “add prepl support to CIDER” sitting somewhere in the back of my head. CIDER is built firmly around nREPL, but prepl ships with Clojure itself, and the appeal of dropping the external REPL server requirement is obvious. Recently, as part of a broader internals cleanup “mini-project” in CIDER, I finally sat down and put a prototype together: cider#3899.

The good news is that the prototype sort of worked. The bad news is that the more I poked at it, the more I kept running into the same pattern. CIDER assumes ops, sessions, request ids, and a whole structured protocol that prepl simply doesn’t have. The amount of CIDER code that would need to grow “is this nREPL or prepl?” branches added up quickly, and I’d be papering over prepl’s limitations in dozens of subtle places. The exercise was fun, but it ended up reaffirming my long-standing belief that nREPL is a much better fit for editor tooling than prepl is.

The exercise did leave me thinking though. What if, instead of bolting prepl onto CIDER, I built a small standalone client in the spirit of inf-clojure and monroe? Something tiny and focused that doesn’t have to pretend to be CIDER, and where prepl’s quirks would be the design rather than something to work around.

Conveniently, I was on vacation in Portugal at the time, where I spent a few days in Porto, and the name pretty much picked itself. Port was born. It kept us firmly in the land of fun, drink-inspired Clojure-on-editor names: CIDER, Calva (after Calvados, the apple brandy), and now Port (the famous fortified wine). The protocol Port talks to is prepl, over a TCP port, so the pun was hard to pass up.

This time around I didn’t manage to land on a backronym I love (at least not yet). The contenders so far:

• prepl omnipotent repl toolkit (my favorite so far)
• prepl-operated repl toolkit
• peak optimized repl toolkit

Naming is hard. I remain open to better suggestions. :D

Scope, or what Port isn’t

Port is a side project. I don’t plan to invest serious time in it past the point I consider it feature-complete, which won’t be far beyond what’s already there. The deliberate goal is to keep it simple and focused, and its feature set will stay close to inf-clojure and monroe. Port is not competing with CIDER. If you want the full feature set (debugger, inspector, test runner, profiler, structured stacktraces, refactor support), CIDER + cider-nrepl is, and will remain, the way.

What Port gives you today is a small, dependable Clojure REPL that you can hook into Emacs without any external dependencies, just a stock Clojure JVM with a prepl listening on a port.

A few architectural notes

If you’re up for the long version, doc/design.md goes deep. Here’s the short version of what prepl gives you compared to nREPL:

• No bencode. prepl emits EDN-tagged maps, one per line. This might be a feature or a problem, depending on your perspective.
• No middleware. Whatever the server prints is what you get. No interception, no extension surface.
• No sessions. There’s one thread per TCP connection.
• No ops. You send a Clojure form, the server evaluates it, and prints back tagged messages: :ret, :out, :err, :tap, plus an :exception true flag on errors.
• No request id. This is the main issue. Tags identify the kind of message, not which request produced it.

That last point is the central design constraint. If you want to issue a request and reliably read back its result without accidentally consuming output from an unrelated background future or tap>, you need to layer correlation on top of the protocol. Port does this with two tricks:

1. Two sockets per session. A user socket drives the REPL buffer with raw streaming output, and a separate tool socket carries helper-command requests. Background prints from future/agent on the user thread don’t bleed into the tool channel.
2. A bootstrap form. On connect, the tool socket evaluates a one-shot form that defines a port.tooling/-eval wrapper. Every subsequent helper call goes through it, which captures *out* / *err* and returns a tagged map containing the request id. The client matches the id against a pending-callback registry.

This is what nREPL provides via sessions and ops, just reinvented at the TCP layer. It’s a fair amount of work for something nREPL gives you for free, which only strengthens my view that nREPL is the better protocol for editor tooling. Still, it was an interesting and educational exercise.

Zero dependencies

One thing I’m fairly proud of: Port has no hard dependencies. You’ll want either clojure-mode or clojure-ts-mode installed for the source-buffer side of things, but Port itself only soft-depends on them via runtime fboundp checks. Hook it onto whichever one(s) you actually use. I intend to keep it that way. Dependency creep is a real problem in the Emacs (every?) ecosystem, and a small package should stay small.

What’s there in 0.1

I tagged v0.1.0 yesterday. It’s small but already perfectly usable:

• M-x port “jacks in” (bootstraps) (auto-detects deps.edn / project.clj / bb.edn, starts a server and connects to it)
• single-buffer REPL with persistent input history, completion, and eldoc at the prompt
• interactive evaluation from source buffers with pretty-printed results
• structured stacktrace buffer with cause chain and navigable frames
• M-. find-definition that follows into jar sources
• doc/source/apropos/macroexpand helpers

MELPA submission is queued up next. After that, expect Port to be in burst-driven maintenance mode like most of my smaller projects.

Feedback, ideas, and contributions are most welcome. The issue tracker is the right place.

Closing thoughts

Funny thing, I’d never actually written any code against prepl until I started this project. It was fun to spend some quality time with the “competition” of my beloved nREPL. Working with a different protocol always teaches you something about the one you’re used to, and I came away from this with a renewed appreciation for both: prepl is genuinely elegant for what it is, and nREPL is genuinely well-designed for what we use it for.

Big thanks to Clojurists Together and everyone else who supports my OSS Clojure work. You rock! Now if you’ll excuse me, I have new releases of CIDER, clj-refactor, and refactor-nrepl to get back to.

Keep hacking!

I work on developing features and fixing bugs in the Linux kernel in areas specific to IBM Power. I use a number of Emacs’ facilities to get my work done.

Magit

I use Magit extensively with clones of various Git repositories from https://git.kernel.org/. I keep learning new (to me) things about git and Magit and using them. I’ve found it useful to learn how things work with the command line before attempting to use them in Magit.

Compilation

This work being with C source code, I make heavy use of M-x compile. I’ve made my life easier by preloading a couple of items in compile-history. I don’t need this everywhere, just in my Linux trees, so I put all of my Linux repositories under ~/linux, and there I’ve created a .dir-locals.el for directory local variables:

((nil . ((compile-history 
	  . 
	  ("nice make -k ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- -j `nproc` all compile_commands.json gtags"
	   "nice make -k ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- -j `nproc` tarzst-pkg"
	   )
	  )
	 )
      )
 )

I do my work on my x86_64 laptop, and cross compile for the powerpc architecture in 64-bit little endian mode. I take advantage of all of the threads available on my laptop. I use nice to make it a bit easier to interactive things while compiling.

The first history item does the big work. I build the all target to build the kernel and modules. I build compile_commands.json to capture the information needed by clangd to use with Eglot. I also keep gtags databases up-to-date, though I should probably drop that since I’m completely using Eglot with clangd at this point.

The second history item creates a .tar.zst file from the kernel and modules, which I transfer to the remote Power partition.

C mode and Eglot

I use c-ts-mode with Eglot. Eglot is integrated with xref.

TRAMP

My test systems are remote, so I need to transfer the kernel and modules over to it. I initially use TRAMP with the scp method to transfer the compressed tar file. If I rebuild and create a new package with the same name, I switch to the rsync method to transfer. This saves several seconds each time.

In both of these cases, I’ve set up keys so I do passwordless authentication.

Non-Emacs things on the remote system

Once I have the tar file on the remote system, there are some non-Emacs things to do. I’m almost certain I can do them in Emacs, as they’re just command line things, but I’m just not used to that and haven’t pushed myself to try it.

• untar the tarball in / (as root)
• run dracut to create an init ramdisk
• optionally remove older kernels and modules
• run grub2-mkconfig to add the new kernel to the GRUB menu
• copy the new grub config file to the right place
• reboot

Since I had no interesting books to read today, nor interesting films to watch, I decided to scavenge for the most intriguing content one can find online. I ended up reading the Linux kernel mailing lists, but those discussions seemed to be 18+, so I settled for the comparatively civil emacs-devel.

For those unfamiliar, emacs-devel is the primary development discussion list for GNU Emacs – where design decisions get made, patches get reviewed, and occasionally where people spend 200 messages arguing about version control software. This is the story of that last one.

2008: “This question is over and decided”

In March 2008, Emacs was migrating from CVS (yes, CVS) to something more “modern”. The two contenders were Git and Bazaar.

• Git, created by Linus Torvalds for the Linux kernel.
• Bazaar was a GNU project, maintained by Canonical

A 236-message thread erupted on emacs-devel. People benchmarked both tools. The results were not subtle. Andreas Schwab, one of the core developers, reported his first impression:

My first impression is that bzr is slow, so slow that it is completely unusable. How can it come that a simple bzr log takes more than a minute to even start? Even cvs log is instantaneous in comparison, although it has to request the log from the server.

David Kastrup found it equally puzzling:

I find this surprising: “git log” is pretty much instantaneous, and git recalculates a code piece’s history in the process. In contrast, one has to tell Bazaar when one copies or moves or renames files, so it should have the information available right away.

The actual numbers:

• git log | head -1 0.012 seconds. The same command with Bazaar took 21.5 seconds.
• Committing a single-file change: 0.08 seconds with Git, 17 seconds with Bazaar.

The benchmarks kept coming. Stefan Monnier, the head maintainer, set the bar low:

I don’t care if Bzr is slower or faster than Git, but in order to switch to Bzr, we need it to be ‘fast enough’. Currently it is not. At the very least the ‘bzr diff’ should not take more than a couple seconds.

Meanwhile, Jonathan Lange, an actual Bazaar developer from Canonical, was in the thread doing tech support.

His recommended workflow for the initial checkout:

An even better way to do the initial download is this:

$ wget http://bzr.notengoamigos.org/emacs.tar.gz

$ tar xzf emacs.tar.gz

$ bzr init-repo emacs-bzr

$ cd emacs-bzr

$ bzr branch ../emacs trunk

$ cd trunk

$ bzr pull –remember http://bzr.notengoamigos.org/emacs/trunk/

Compare that to git clone!

Someone in the thread finally asked the obvious question:

To the emacs maintainers and decision makers: What more information is required to convince bzr is not the right tool at the present moment?

Richard Stallman’s reply:

This decision is not a decision for the present moment. It is a long term decision. So it would be better to wait a few months while Bzr developers improve it, than to make some other “temporary” decision that would probably be hard to reverse.

And in case anyone missed the point, in a separate message:

This question is over and decided. We will use GNU Bzr, because it is a GNU package.

When someone pointed out that this political decision was “wiping away all technical arguments,” RMS replied:

The rule that GNU packages should support each other helps make the GNU system as a whole work better.

Someone asked the obvious follow-up: “Why can’t we just make Git part of the GNU system?”

RMS:

We could include it in the GNU system, but its developers are not likely to want to make it a GNU package.

To be fair to RMS, there’s a real principle here. If the GNU project doesn’t use its own tools, it sends a message that those tools aren’t good enough, which undermines the whole idea of a self-sufficient free software ecosystem. He’d been making this argument for decades, and it had served the project well in many other cases. The problem wasn’t the principle. The problem was that Bazaar couldn’t live up to it.

The 236-message thread, the benchmarks, the Canonical employee’s workarounds; none of it changed the outcome. The decision was political, and the politics were settled.

2008-2012: The long tail

The rest of the world moved to Git. GitHub launched in 2008 and exploded. Emacs contributors, meanwhile, had to learn Bazaar, a tool they used nowhere else, just to submit patches.

Threads like “Help me unstick my bzr, please” and “Can NOT bzr the emacs repos (may be bzr has a memory leak)” became regular occurrences.

Then in 2012, Canonical laid off the Bazaar development team.

2013

In March 2013, a year after Bazaar’s development ceased, John Wiegley posted what everyone had been wanting to say:

We have often debated the merits of Git vs. Bazaar, and which one the GNU project should use for Emacs development. I think now is an appropriate time to revisit this decision.

My main reason for bringing this up again is that Bazaar development has effectively stalled. There are major bugs which have been in their bug-tracker for years now – bugs affecting Emacs development, such as the ELPA repository – which have been ignored all this time.

So, to Richard as the undisputed Czar of all things Emacs: can we now, pretty please, switch to Git?

200 messages followed.

RMS’s first response:

The maintainer says he is fixing some bugs, and I asked him just yesterday to fix the ELPA branch bug. I’d like to give him a reasonable time to do this.

The bug was 1.5 years old. Dmitry Gutov called it out:

Isn’t this a bit late? The bug is 1.5 years old. Was he not aware of it before?

Then RMS revealed his hand:

I am trying to determine whether Bzr is effectively maintained or not. I’d rather get a Yes answer than a No answer.

That’s a remarkably honest thing to say publicly. He wasn’t hiding his preference. He genuinely believed in the principle of GNU projects supporting each other, and he was hoping reality would cooperate.

Joakim Verona, a longtime Bazaar user and Emacs contributor, described the reality on the ground:

I have done my best to be a constructive user of the tool, and I have had many technical difficulties. When I try to find solutions to the issues I notice the following:

• The bzr community is very helpful. This is good.
• There are many well known bugs. There are also many well known patches for these, some of them provided by Emacs developers. They never enter upstream. By “never” I mean years. This is bad.

RMS replied:

I don’t have time to read the Bzr mailing list. Or any development mailing list. The only such list I am on is this one. You might as well tell me to fly to the moon as tell me to read something on the Bzr list.

And when asked whether the users of Bazaar should have a say in whether Bazaar is sufficiently maintained:

When I have to decide whether a maintainer is doing an adequate job or needs to be replaced, I pay attention to whatever relevant information I get. However, to give users “a say” in the decision seems improper, so I don’t do that.

Karl Fogel, a veteran open source developer (author of Producing Open Source Software and one of the original Subversion developers), delivered the sharpest critique in the thread:

Well, really, you don’t have time to pay close enough attention to Bzr development to competently decide whether it’s still a good choice for Emacs. That’s fine – no one has time to do every important thing, and you do many other important things.

But then why do you think you still have the time & mental bandwidth to make this decision well? Why not delegate it to the Emacs maintainers on the grounds that you no longer have time to do a good job of this evaluation?

He pointed out that asking one person about one bug is not a proxy for project health, and that others in the thread had already done more thorough research than RMS could, given his time constraints.

RMS’s reply:

Because more than Emacs is at stake here.

One line, but it’s the core of his worldview. If the flagship GNU project abandons a GNU tool, what signal does that send to every other GNU package? He wasn’t wrong about the stakes. He was wrong about the tool.

Karl pushed once more:

You should either devote enough time to evaluating Bzr’s maintenance state to get a reliable answer, or delegate to someone who can do so. Instead, you’re asking the maintainers to rely on your investigation… yet you clearly don’t have time to do a good job. This is a poor use of everyone’s time.

RMS:

I already have a plan for how to proceed on this, and I am doing it.

No details. No timeline. No delegation. Trust me.

Meanwhile, Stefan Monnier, posted exactly one substantive message in the entire 200-message thread:

Just like I didn’t fight Richard’s choice of Bazaar, I don’t care very much whether we keep using Bazaar or we change to Git, Monotone, Darcs, Mercurial, OpenCM, Fossil, younameit.

The only thing I care for now is to move away from Bazaar for the ’elpa’ branch because Bazaar can’t handle it properly.

Leo Liu summarized what everyone was thinking:

Most GNU projects aren’t using BZR as you might be aware.

While helping BZR fixing bugs might be a gain for BZR, it is a loss as a whole for GNU. Volunteers spend their spare time on GNU projects and if 20% of that time is taken up by wrestling with BZR, it becomes costly to the point discouraging people from joining.

For the greater good of GNU, move off BZR seems like the only sound choice.

The thread ended without a clear resolution. RMS had a plan. He was working on it. The 200 messages didn’t produce a decision, but they did make the community’s position unmistakable.

2013: The ELPA branch breaks

Later that year, Stefan made the practical move that set the stage for everything that followed. The ELPA branch was broken on Bazaar, a bug that crashed on checkout, with no one left to fix it. Stefan moved it to Git, and his announcement showed exactly the kind of careful leadership that had kept Emacs development running through all of this:

I’m not terribly happy about this change, since it means we’ll be using two different tools (Git for ’elpa’ and Bzr for ’trunk’), but I really see no other way out.

I don’t want this to be a discussion about the merits/pitfalls of Git vs Bzr, and this is not an occasion to discuss the use of Git for the ’trunk’ either.

He knew exactly what everyone was thinking “if Git is good enough for ELPA, why not for trunk?” and he headed it off. One problem at a time.

2014: ESR pushes the button

By August 2014, Eric S. Raymond had the conversion scripts ready.

He’d been working on it quietly:

You haven’t heard much about it because the hard work is all done. I have the scripts ready to go and need only about eight hours’ notice before pushing the button.

The actual migration happened in November 2014. On November 13th, ESR posted a seven-word message:

Commits are open. Have at it.

Which some even described as heroic.

Six years of debate, 236 messages in the 2008 thread, 200 messages in the 2013 thread, Stefan’s years of quiet maintenance, countless “help me unstick my bzr” pleas, one dead version control system, and it ended with seven words.

The aftermath

The days following the migration were educational. Half the core contributors had never used Git:

• “This Is The Git Help Mailing List”
• “git pull fails with merge conflicts. How can this possibly happen?”
• “A simple git workflow for the rest of us”
• “need help adjusting workflow to git”
• “Good book on Git”
• “Obscure error/warning/information message from git pull” (124 messages)

These were people who’d been developing one of the most important text editors in the world for years, asking basic Git questions, because they’d been stuck on Bazaar while the rest of the world moved on.

What a bzr saga! Anyway, better than any film I could have watched tonight.

As celebrated as Emacs is for its programmability, I find the actual process of developing Emacs Lisp (Elisp) to be quite underwhelming. Developing in Elisp has meant learning its libraries and idioms, which is to be expected. What I really don’t care for though are the arcane keybindings associated with doing basic things like evaluating, navigating (Xref), and debugging (especially debugging). While I’ve already committed to muscle memory most of said keybindings, I’d argue that having a mouse-based “point and click” interface is beneficial for both novice and experienced Elisp developers alike, as it lets one focus on the code and not on recalling the right key incantation all the time.

The addition of context-menu-mode in Emacs 28 has provided the opportunity to build a mouse-based UI for Elisp development and I’m happy to announce the availability of one in the latest v1.3.0 update to Anju, now on MELPA.

To get an idea of what’s available in the v1.3.0 update, here’s a screenshot of the context menu when normally editing an Elisp file where the point is on the symbol foo.

If foo is instrumented for debugging and run, the context menu is adjusted to provide Edebug commands as shown below.

The context menu enhancements provided by Anju take full advantage of built-in functions that identify context at point. Is the point on a symbol? In a function? In an ERT test? On a lambda? The menu items added by Anju take these factors into account to provide a relevant menu offering.

Users can read more about Anju’s context menu enhancements for Elisp development at Emacs Lisp Context Menu (Anju User Guide).

Some backstory with Edebug

Back in 2024, I did a deep dive into Edebug so as to give a presentation on it at the EmacsSF meetup. In doing so, I realized that all the core features for having an Elisp IDE were there, but no good UI to present it. I set upon prototyping one using Transient, with decidedly mixed results due to both Edebug and Transient fighting each other over window management.

A later Edebug UI prototype using the toolbar was attempted but it also had its issues, particularly with layout (or lack thereof) and toolbar-specific bugs in macOS. But a benefit of using the toolbar was that its UI interactions did not interfere with window management. The context menu also shares this benefit.

Closing Thoughts

The context menu has markedly improved my developer experience with Elisp, as I find myself using it more than typing out keybindings. Even with keybindings, I’ll use the Casual Elisp Transient to accomplish most Elisp interactions that don’t require Edebug.

That said, I’m not here to eschew keybindings. I still use them, when convenient. But in many circumstances they are not. The context menu can provide an easier way to achieve the same thing. Isn’t that a good thing?

I’ve been using ICanHazShortcut for years. I originally started using it to have an easy way to switch to Emacs from anywhere in my system. Eventually, I added Safari and HomeKit to the list of apps I can invoke with a simple keypress but most of my ICanHazShortcut shortcuts are Emacs related. For example, I have F9 mapped to Emacs capture so that I can invoke any Org capture template from anywhere on my system. That’s really handy and I use it several times a day. I also have a shortcut to invoke Emacs Everywhere so that I can escape into the comfort of Emacs when entering data in some other app.

Today (Sunday, as I write this) I received a notification that a new version of ICanHazShortcut was available. It’s completely rewritten in Swift from Basic and has some new capabilities. You can read about them at the above link. For me, not much has changed. The new version continues doing what ICanHazShortcut has always done.

ICanHazShortcut is a minimal app that simply provides a shortcut for any command that you can specify in the terminal. There are plenty of more full featured key mappers available that may be better for more complicated situations but I find ICanHazShortcut perfect. It’s light weight and easy to configure. I almost never mess with ICanHazShortcut’s configuration. The last time I changed it—to add HomeKit, I think—was years ago. It truly is a set it and forget it app.

If you want a simple app for invoking Emacs—or anything else—in various ways, take a look at ICanHazShortcut; it’s worked very well for me.

People are getting Emacs 31 ready for release. Looking forward to that! See emacs/etc/NEWS.31 for details.

Lots of posts for the Emacs Carnival theme of "May I recommend…", yay!

• Emacs 31:
  • The emacs-31 branch has been created! (Irreal)
  • openSUSE package for emacs-31 (@thaodan)
• Upcoming events (iCal file, Org):
  • London Emacs (in person): Emacs London meetup https://www.meetup.com/london-emacs-hacking/events/314540885/ Tue May 12 1800 Europe/London
  • Emacs Berlin: In-Person-Only Emacs-Berlin Stammtisch https://emacs-berlin.org/ Tue May 12 1900 Europe/Berlin
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed May 13 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu May 14 0000 Asia/Singapore
  • M-x Research: TBA https://m-x-research.github.io/ Wed May 20 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat May 23 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
• Emacs configuration:
  • Marcin Borkowski: describe-personal-keybindings (Irreal)
  • My Dotfiles: macOS Bootstrap and an Emacs Distribution (Reddit)
  • Backpack Emacs hits version 0.5
• Emacs Lisp:
  • Amin Bandali: FFS code review with Protesilaos (Prot)
  • The Emacs's Gamegrid library #1, #2, #3, #4
• Appearance:
  • Recent Commits to emacs:master: Introduce 'margin' face for window margin background
  • Emacs theme that looks like v0.10+ Neovim's default dark theme (Reddit)
• Navigation:
  • TAGS, Etags and system headers
  • Emacs: writing a project.el backend
  • Emacs Buffer Comparison Made Easy With Ebuffers 2026 05 10 02:31:35 (05:31)
  • LIVE: bribing myself to work on async Rust TCP connections (02:35:52, Emacs navigation chapter at 2:00:15)
• TRAMP:
  • Notes on using GNU Emacs' Tramp system in an unusual shell environment (lobste.rs)
• Dired:
  • James Dyer: A Zoomed in vc dir for the Current Directory in dired
• Writing:
  • markdown-ts-mode got a major overhaul and is now part of Emacs 31
  • Dave Pearson: blogmore.el v4.5.0 - add blogmore-set-as-cover
    • v4.4.0 - blogmore-become-like
  • jw.el: Just Write, a microjournaling tool (uses external binary) (@liberty@mathstodon.xyz)
• Denote:
  • Organising Series with denote-sequence — Alex Carney (@alcarney)
• Org Mode:
  • Org Mode requests: [FR] ox-md: Export custom-id search strings (::#) as anchors
  • grove.el - an Obsidian-like note-taking mode for Emacs (r/emacs, r/orgmode, Irreal, HN, HN)
  • mon workflow emacs (18:31)
  • Spacemacs | Org-mode Table Spreadsheet Formula | Productivité (05:19)
  • Import, export, and integration:
    • Tiny package for org links which base64 embed files into HTML export for sharing (Reddit)
    • Note about needing to escape things in Org macros (@pabryan@mathstodon.xyz)
    • LuaLaTex y fontspec (Orgmode) - FediverseTV (@emacs_org@fediverse.tv)
    • Config for using multiple org-publish projects (@yugaego@fosstodon.org)
    • Blog-Umzug? | Jan Iversen (@razorback@nerdculture.de)
    • sync.el - sync Org files with git automatically (Reddit)
    • Andros Fenollosa: twtxt vs Org Social: the evolution of an idea
    • Descubriendo la red Org-social - FediverseTV (@emacs_org@fediverse.tv)
  • Org development:
    • ox-latex.el: New variable org-latex-descriptive-environment
    • ob-tangle: Make tangling from archived trees optional
• Completion:
  • Emacs Completion Showcase with VOMPECCC (video) (YouTube 01:08:43, Reddit, HN, lobste.rs)
  • Follow-up: vertico-buffer-frame, a child-frame experiment for vertico-buffer (Reddit)
  • fzf-async (Reddit)
  • Yuta.el: native fuzzy finder, Lsp Completion, and command palette for Emacs (uses external CLI tools) (Reddit)
• Coding:
  • My Doom Emacs setup for Rust development in less than two minutes (01:36)
  • emacs-forgejo | Thanos Apollo (@csantosb@sigmoid.social)
  • hprpl-mode for the HP-48G
  • Finally go-to-definition w/ Eglot on JVM languages (Kotlin and Java)! do you know how to improve it?
  • Using our new Lua debbuger: LuaProbe, we made an Emacs package for it (Reddit)
  • Configurando o Windows para Programar Jogos em C | Indie Game Dev (48:38)
  • Sweep: SWI-Prolog Embedded in Emacs (@PuercoPop)
  • jao: geiser moved to codeberg - Scheme interfaces
• Math:
  • The Simple Emacs Spreadsheet
• Shells:
  • Toggle an Emacs terminal with a single keystroke using shell-pop (Recently Refactored) (Reddit)
  • Just a quick "Eat" survey
  • termit: Terminal emulator for Emacs (@hajovonta@mastodon.online)
• Web:
  • Einar Mostad: Speed improvement hack for dired with EWW - browse-url-handlers
• Mail, news, and chat:
  • What improvements would you like to see in elfeed? (@minad@mastodon.world)
  • Add elfeed-tree-mode · emacs-elfeed/elfeed@072a609 · GitHub (@minad@mastodon.world)
• Multimedia:
  • contrapunctus/sxiv.el: Launch (n)sxiv ((Neo) Simple X Image Viewer) (@contrapunctus@fe.disroot.org)
• AI:
  • I made elisp-quality-ai: AI-friendly quality reports for Emacs Lisp projects
  • Emacs with Org-Mode and Claude for Apple MacBook (HN)
  • ox-skills: manage AI agent skills in Org-mode (Reddit)
  • display-buffer-alist config for claude-code (@cyberwolf@infosec.town)
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-05-05 / week 18
  • Sacha Chua: Emacs Carnival May 2026: "May I recommend…"
    • May Emacs Carnival: Carlos Pajuelo
    • May I Recommend EWM | Dilip's Log
    • Sacha Chua: From David Dimagid: What we talk about when we talk about recommending Emacs packages
    • May I recommend… escaping the minibuffer (@vanni@mibl.vannilla.org)
    • May I recommend… vibemacsing? | Giampaolo Guiducci (@gosub@fosstodon.org)
    • May I recommend… to only add items to your init files you understand and document? Martin Stemplinger
    • Curtis McHale: Emacs Carnival: May I recommend…
  • Amin Bandali: Emacs Chat with Sacha Chua (YouTube 01:12:31, Irreal, Sacha)
  • Sacha Chua: Emacs Chat 22: Shae Erisson (YouTube, 01:02:36)
  • I just dont get it… - long discussion about Emacs Lisp and customization
  • Emacs ATX Meetup. May 2026. GNU Hyperbole. (01:44:31)
  • Thread about what makes Emacs easy for you (@chiply@fosstodon.org)
  • Kent Pitman, Ramin Honary, Screwlisp #climate #emacs autocomplete #lisp #unix_surrealism #logic #lispyGopherClimate - toobnix (@screwlisp@gamerplus.org)
  • Curtis McHale: The gravitational pull of familiar tools
• Other:
  • veer66/ya-sort-lines: Yet-another sort lines - Codeberg.org (@veer66@mstdn.io)
  • jamesendreshowell/ramb: Emacs package Really Actually Make Backups - Codeberg.org (@jameshowell@fediscience.org)
  • Protesilaos: Emacs: save any buffer as PDF (my new buffer-to-pdf package)
  • Corwin Brust: last-rev.pl - find the most recent commit to each Emacs branch (or other Savannah projects)
  • James Cherti: A Technical Guide for Compiling Emacs and its Packages for Maximum Performance on UNIX or GNU/Linux systems
  • Protesilaos: Re: Emacs and keyboard ergonomics (Irreal)
• Emacs development:
  • emacs-devel: Re: Tail recursion - Lynn Winebarger - emacs-31 probably not going to have igc
  • New variable 'completion-frontend-properties' (bug#80990)
  • Bump master Emacs version to 32.0.50
  • Introduce 'margin' face for window margin background
  • nadvice.el: Make it easier to find how to change an interactive-form
  • keyboard.c: Allow SIGINT to `quit` in batch mode, instead of exit
• New packages:
  • apple-container-tramp: TRAMP integration for apple container (MELPA)
  • claude-code-context: Share buffer context with Claude Code (MELPA)
  • folgezett: Folgezettel IDs for org-roam (MELPA)
  • gnus-browse-url-in-article: Smarter browse-url for Gnus articles (MELPA)
  • har-viewer: Major mode for viewing HTTP Archive (HAR) files (MELPA)
  • indigo: Emacs interface to the Indigo cheminformatics library (MELPA)
  • nucleo-completion: Nucleo-backed completion style (MELPA)
  • shannon-max: Analyze your keybindings with information theory (MELPA)
  • verdict-dart: Dart runner for verdict (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, 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 e-mail me at sacha@sachachua.com.

Most Linux distributions ship generic binaries compiled to run safely on a vast array of older hardware configurations. While this ensures broad compatibility, it sacrifices the speed that comes from using the specific, modern instruction sets of your processor. Compiling Emacs directly from source allows instructing the compiler to generate machine code targeted at your CPU architecture, resulting in a faster and more efficient runtime environment.

Before we dive in, please consider sharing this article on your website/blog, Mastodon, Reddit, X, or your preferred social media platforms. Sharing it will help fellow Emacs users discover better ways to manage code folding.

Beyond raw hardware optimization, building from source enables dropping decades of legacy compatibility layers and embracing modern desktop technologies. For example, Wayland users can configure the build to bypass old X11 display protocols in favor of a Wayland environment, ensuring smoother rendering and better system integration.

Additionally, this article details how to optimize the internal native Lisp compiler, which transforms Lisp packages into machine code to ensure that every Emacs package in your configuration operates at its maximum potential speed.

Here is the step-by-step process for compiling a highly optimized Emacs binary and packages.

Installing dependencies

Arch Linux

On Arch Linux, the cleanest and most native method to resolve build dependencies is to use the official Emacs PKGBUILD, which automatically read the official dependency list and install them:

mkdir -p ~/emacs-deps
cd ~/emacs-deps
wget https://gitlab.archlinux.org/archlinux/packaging/packages/emacs/-/raw/main/PKGBUILD
makepkg --syncdeps --nobuild

NOTE: Once makepkg finishes installing the dependencies, you can safely delete the ~/emacs-deps directory.

Debian, Mint and Ubuntu

On Debian-based systems, the most efficient method to gather dependencies is to use the package manager to automatically fetch them based on the distribution’s source package. You must first ensure that source repositories are enabled:

• Open /etc/apt/sources.list with root privileges in your text editor.
• Find the lines starting with deb-src (Read: “sources.list format” on Debian Wiki) and uncomment them by removing the # at the beginning of the line.
• Update your package lists and download the install Emacs dependencies:

sudo apt update
sudo apt build-dep emacs

Other Linux Distributions (Generic)

If you are using a distribution not listed above, you will need to use your distribution’s specific package manager to install the required development libraries. Look for packages that include the library headers, typically suffixed with -dev or -devel.

Here is the master list of upstream library names required to compile this specific Wayland and Native-Comp optimized build:

• Core Build Tools: gcc, make, autoconf, automake, pkg-config (or pkgconf), git, texinfo
• Native Compilation Engine: libgccjit (Ensure this matches your GCC version)
• System and Core Libraries: glib2, gnutls, zlib, ncurses, sqlite3, tree-sitter, gmp
• Graphics and Wayland Toolkit (PGTK): gtk3, cairo, harfbuzz, pango, dbus
• Image Formats: libjpeg (or libjpeg-turbo), libpng, libtiff, giflib, libwebp, librsvg2, lcms2
• Fonts and Text Shaping: fontconfig, freetype2, libotf, m17n-lib, libxml2

Optimizing the Native Lisp Compiler

Fine-Tuning Native Compilation

Before building Emacs with native compilation support, we will optimize how Emacs transforms Lisp packages into machine code. This is managed via the native-comp-compiler-options variable. While the main Emacs build uses your global CFLAGS, this variable specifically instructs libgccjit on how to handle every .el file it encounters.

Add the following to your early-init.el file:

;; Display the architecture using:
;;   gcc -march=native -Q --help=target | grep march
;;
;; The above command asks the compiler to resolve native for your current CPU
;; and display the resulting target. For example, if the output shows
;; -march=skylake, you know that skylake is the identifier you should pass to
;; -mtune and -march.
(setq my-cpu-architecture "CHANGE_THIS_TO_YOUR_ARCHITECTURE")

;; `native-comp-compiler-options' specifies flags passed directly to the C
;; compiler (for example, GCC) when compiling the Lisp-to-C output
;; produced by the native compilation process. These flags affect code
;; generation, optimization, and debugging information.
(setq native-comp-compiler-options `(;; The most meaningful optimizations:
                                     "-O2"
                                     ,(format "-mtune=%s" my-cpu-architecture)
                                     ,(format "-march=%s" my-cpu-architecture)
                                     ;; Reduce .eln size and compilation
                                     ;; overhead.
                                     "-g0"
                                     ;; Good defensive choice for Emacs
                                     ;; stability.
                                     "-fno-omit-frame-pointer"
                                     "-fno-finite-math-only"))

(setq native-comp-driver-options '(;; -Wl,-z,pack-relative-relocs compresses
                                   ;; relocation tables to reduce file size and
                                   ;; slightly improve load times.
                                   "-Wl,-z,pack-relative-relocs"
                                   ;; -Wl,-O2 applies standard linker-level
                                   ;; optimizations (like string merging) to the
                                   ;; generated shared object.
                                   "-Wl,-O2"
                                   ;; -Wl,--as-needed prevents the linker from
                                   ;; recording dependencies on libraries that
                                   ;; are not actually used by the code.
                                   "-Wl,--as-needed"))

IMPORTANT: Change CHANGE_THIS_TO_YOUR_ARCHITECTURE to your specific architecture. Run the following command to display the CPU architecture:

gcc -march=native -Q --help=target | grep march

The above command asks the compiler to resolve native for your current CPU and display the resulting target. For example, if the output shows -march=skylake, then replace CHANGE_THIS_TO_YOUR_ARCHITECTURE with skylake.

(If you prefer automatic CPU architecture detection, refer to the comments section below. I shared a function that detects the CPU architecture using gcc and adds it to the configuration.)

NOTE: Avoid adding -mtune=native and/or -march=native to the native-comp-compiler-options variable. While these flags work in global CFLAGS, libgccjit, the library responsible for native compilation, often fails to resolve the native keyword correctly. This happens because the JIT interface does not always trigger the same host-probing logic as the standalone GCC driver.

The rationale behind the selection of these flags is as follows

• The choice of -O2 is an intentional balance. While -O3 may provide small performance gains in some workloads, it can also increase binary size and occasionally reduce responsiveness. -Ofast is generally discouraged because it enables aggressive floating-point optimizations.
• Using -g0 disables the generation of debug symbols for .eln files, which reduces their size on disk and speeds up the compilation process itself.
• -fno-omit-frame-pointer The Emacs developers recommend using this flag to disable omit-frame-pointer. Although enabling omit-frame-pointer frees up a general-purpose CPU register, it does not yield significant performance gains on modern architectures and can lead to bugs that are difficult to debug. According to Eli Zaretskii, an Emacs developer: “See bug#76180. This is in the context of the igc branch, where omit-frame-pointer is particularly troublesome, though it also causes problems in other situations. For further details, see etc/DEBUG in the Emacs source tree.”
• The -fno-finite-math-only flag prevents the compiler from assuming that floating-point operations never produce NaN or infinity values. This flag is mostly defensive because GCC does not enable -ffinite-math-only at -O2 by default, but it can help avoid unsafe assumptions if additional aggressive optimization flags are introduced later.

Purging the Native Cache to Force JIT Recompilation

After modifying the native-comp-compiler-options and/or native-comp-driver-options variables, you must force Emacs to rebuild your packages. Ensure Emacs is closed and delete all existing .eln binaries using the following command:

find ~/.emacs.d/ -name '*.eln' -delete

Because Emacs uses a deferred compilation engine (Native JIT compiler), you do not need to manually trigger a build script. Simply launch Emacs and begin your normal workflow. As Emacs loads your packages and detects the missing .eln files, it will spin up background threads to recompile them using your new optimization flags.

Compiling Emacs for Performance

Step 1: Cloning and Preparing the Source

To build Emacs, you must first obtain the source code from the official mirror and switch to a stable release branch:

git clone https://github.com/emacs-mirror/emacs
cd emacs
git checkout "emacs-30.2"

NOTE: The official Savannah Git repository at https://git.savannah.gnu.org/git/emacs.git can occasionally be slow or unreliable, so this guide uses the official GitHub mirror instead.

We target a specific release tag like emacs-30.2 (If you desire to install another version, you can display tags using the git tag command) to ensure a stable foundation. Building from a tagged release, rather than the bleeding-edge development branch like the master branch, minimizes the risk of build failures or experimental regressions that could impact your daily productivity.

Standard cleanup is often insufficient when switching branches or recovering from a failed build. Execute the following commands to ensure a pristine environment where no residual artifacts can interfere with the new build:

git reset --hard HEAD
git clean -f -d -x
rm -fr .git/hooks/*

(Executing these commands acts as the ultimate factory reset for your repository, which is important when switching between major Emacs versions. Emacs has a highly complex build process where the C core compiles its own Lisp files; if leftover artifacts from a previous configuration, such as cached object files, old Makefiles, or stale byte-compiled .elc scripts, git hooks, are left behind, they can silently contaminate the new build and cause segmentation faults or compile-time errors. Together, these commands guarantee a pristine, predictable environment.)

Once inside the repository, all subsequent configuration and compilation commands are executed from this directory.

Step 2: Generating the Configuration Script

Emacs uses the Autotools build system, which requires generating the final configuration script before it can be used:

./autogen.sh

This shell script reads the developer configuration files provided in the repository and generates the final ./configure script. It sets up the necessary infrastructure to inspect your specific environment, locate system libraries, and prepare the Makefile.

Step 3: Setting Compiler and Linker Flags

To enhance runtime performance, we must export specific variables that instruct the C compiler and linker to optimize the resulting binary for the host CPU:

export CFLAGS="-O2 -pipe -march=native -mtune=native -fno-omit-frame-pointer -fno-plt -flto=auto"
export LDFLAGS="-Wl,-O2 -Wl,-z,now -Wl,-z,relro -Wl,--sort-common -Wl,--as-needed -Wl,-z,pack-relative-relocs -flto=auto"

The CFLAGS variable tells the compiler to apply safe, general-purpose optimizations (-O2), optimize instruction scheduling for the specific CPU compiling the code (-march=native and -mtune=native), store the metadata necessary for the linker to later perform cross-module optimization (-flto=auto), disable omit-frame-pointer (-fno-omit-frame-pointer), use memory pipes instead of temporary files to speed up the build (-pipe), and remove indirect PLT calls to external functions, improving runtime call efficiency at the cost of slightly higher startup and dynamic loading overhead (-fno-plt).

The LDFLAGS variable instructs the linker to apply additional optimization passes to the final executable (-Wl,-O2), group common symbols to reduce duplicate storage (-Wl,--sort-common), avoid linking unused shared libraries (-Wl,--as-needed), reduces binary size by performing a global analysis to inline functions and remove dead code across the entire program (-flto=auto), compress relative relocations to reduce relocation overhead and binary size (-Wl,-z,pack-relative-relocs), resolve all dynamic symbols at startup, trading slightly slower launch time for faster, more consistent runtime execution (-Wl,-z,now -Wl,-z,relro). Together, these flags help produce a smaller, more memory-efficient executable with improved startup and runtime performance.

NOTE: You must ensure CC are exported to the exact gcc version that matches your libgccjit version. For example: export CC="/usr/bin/gcc-11".

Step 4: Configuring the Build

We run the configure script to select exactly which features to include.

For X11 users:

./configure \
  --with-x \
  --with-x-toolkit=gtk3 \
  --without-toolkit-scroll-bars \
  --with-cairo \
  --without-xft \
  --with-harfbuzz \
  --without-libotf \
  --with-gnutls \
  --without-xdbe \
  --without-xim \
  --without-gpm \
  --disable-gc-mark-trace \
  --enable-link-time-optimization \
  --with-gsettings \
  --with-modules \
  --with-threads \
  --with-libgmp \
  --with-xml2 \
  --with-tree-sitter \
  --with-zlib \
  --without-included-regex \
  --with-native-compilation \
  --with-file-notification=inotify \
  --without-compress-install

For Wayland users:

./configure \
  --without-x \
  --with-pgtk \
  --with-toolkit-scroll-bars \
  --with-cairo \
  --without-xft \
  --with-harfbuzz \
  --without-libotf \
  --with-gnutls \
  --without-xdbe \
  --without-xim \
  --without-gpm \
  --disable-gc-mark-trace \
  --enable-link-time-optimization \
  --with-gsettings \
  --with-modules \
  --with-threads \
  --with-libgmp \
  --with-xml2 \
  --with-tree-sitter \
  --with-zlib \
  --without-included-regex \
  --with-native-compilation \
  --with-file-notification=inotify \
  --without-compress-install

The rationale behind the selection of these flags is as follows

• --enable-link-time-optimization Instructs the build system to natively apply link-time optimization. This ensures the Emacs build scripts coordinate the optimization properly across all compiled object files to produce the fastest possible executable. When you pass this to ./configure, the build system actively probes your environment. If you look at the configure.ac script, you will see it attempts to find the number of available CPU cores. It then automatically injects -flto=N (where N is your core count) into the build flags. More importantly, this flag ensures that archiving tools like ar and ranlib are configured to use the correct LTO plugins.
• --disable-gc-mark-trace: Disable the GC mark trace buffer for about 5% better garbage collection performance. It removes debugging code from the garbage collector marking phase. This provides a reduction in overhead during garbage collection cycles, leading to a more responsive experience during memory-intensive tasks.
• --with-native-compilation Enable native compilation. (I omitted the aot flag to instruct the build system to skip compiling the built-in Lisp files during the make step. Instead, Emacs defers this work until runtime, where it will use the optimizations in native-comp-compiler-options and native-comp-driver-options while compiling all .el files the first time Emacs is launched.)
• --with-cairo and --with-harfbuzz enable modern text rendering.
• --without-compress-install By default, Emacs compresses its installed Lisp files to save disk space. Using this flag keeps the files uncompressed. The benefit is faster load times when Emacs needs to read these files from disk, as it skips the decompression step entirely.
• --without-xft Disable xft because modern Emacs rendering no longer needs it. Modern GTK builds of Emacs use Cairo + HarfBuzz handle rendering.
• --without-included-regex Makes Emacs use the system libc regex implementation. On contemporary Linux systems using glibc, the system regex engine is usually better optimized and maintained than Emacs’s bundled GNU regex implementation.
• --with-libgmp Enables GMP, the GNU Multiple Precision Arithmetic Library, an optimized engine Emacs relies on to calculate arbitrary-precision integers (bignums) at bare-metal speeds. Modern Emacs workflows constantly process massive numbers in the background. If you disable this flag or fail to install the system library, Emacs is forced to fall back on mini-gmp, a generic, software-only C implementation designed strictly for portability rather than speed.
• --without-xim: Disable XIM, a legacy X Input Method protocol used primarily for typing complex languages (like Chinese, Japanese, or Korean) on old X11 systems. If you use GTK3/Wayland, modern input methods handle this instead. Disabling this is recommended for Wayland/PGTK users as it removes unnecessary X11-specific code.
• --with-file-notification=inotify Guarantees that the build will use the Linux kernel’s efficient event-watching API rather than falling back to slow, resource-heavy polling if the detection fails.
• --with-gsettings Enable communication with the GTK configuration storage system. This allows inheriting system-wide preferences for themes, fonts, antialiasing hints…
• --without-libotf: Disables the legacy OpenType Font library. This is recommended for modern builds that use HarfBuzz (--with-harfbuzz), as HarfBuzz handles text shaping more efficiently. Disabling this library reduces binary size without sacrificing font quality in modern desktop environments.
• --with-gnutls: Enables secure network communication. This is required for secure package installation from MELPA/ELPA and for browsing HTTPS websites via EWW.
• --without-xdbe: Disables the X11 Double Buffer Extension. This protocol is redundant for modern builds because both the PGTK (Wayland) and GTK3 (X11) layers handle window buffering internally. Disabling it simplifies the binary and ensures Emacs uses modern rendering paths.
• --without-gpm Disable General Purpose Mouse (GPM), a background service that provides mouse support for the Linux console (the text-only TTY you see before logging into a graphical desktop). Unless you plan to use Emacs in a bare-metal Linux console (outside of a terminal emulator like Alacritty, Foot, or GNOME Terminal), GPM is unnecessary. Modern terminal emulators use their own internal protocols for mouse interaction that do not rely on the GPM daemon.

Additional flags to pass to ./configure

If your workflow is primarily text-based, you can significantly reduce the number of external libraries linked to your binary. However, each omission comes with a specific trade-off:

• --without-sound Disables support for audio notifications. You will not hear the audible system bell or sound cues from productivity packages like Pomodoro timers or chat clients.
• --without-libsystemd Disables the ability for Emacs to communicate with systemd. You cannot use advanced systemd service features, such as Type=notify, which allows systemd to know exactly when the Emacs daemon is fully loaded and ready.
• --without-dbus: Disables D-Bus integration in Emacs. This produces a slightly leaner build, but removes integration with desktop services that rely on D-Bus. Depending on the desktop environment and enabled packages, this can affect desktop notifications, interaction with services such as GNOME Keyring, file manager integration, power and network state notifications, and various portal-based desktop features. It is generally safe on minimal Emacs GUI builds or terminal-only setups, but many modern Linux desktop environments expect D-Bus support.
• --without-gconf Disables support for GConf. This is a deprecated GNOME configuration system that was replaced by GSettings. Disabling it ensures your build is not carrying legacy, obsolete desktop integrations.
• --without-sqlite3 Disables the built-in SQLite engine. This breaks modern packages that rely on a local database for performance, such as org-roam or certain mail indexers.
• --without-m17n-flt Disables the m17n library for complex text layout. While fine for English-only workflows, this will cause rendering issues (incorrect character joining or positioning) for complex scripts like Indic or Thai.
• --without-selinux Disables Security-Enhanced Linux support. On systems where SELinux is active, Emacs will be unable to preserve or manage SELinux security contexts when creating or copying files, potentially leading to permission issues or security policy violations.
• --without-libsmack Disables Smack security support. Similar to SELinux, if your Linux distribution uses the Smack kernel security module, disabling this prevents Emacs from managing those specific security contexts on files.
• --disable-build-details: Omits build metadata, such as your machine’s hostname and the compilation timestamp, from the final executable. While this doesn’t provides performance or startup speed benefits, it ensures a “reproducible build” and prevents your personal system details from leaking if you share your compiled binary.
• --without-gif, --without-jpeg, --without-png, --without-rsvg, --without-tiff, --without-xpm, --without-webp Disabling these prevents Emacs from linking against heavy image processing libraries. Emacs will be unable to render these image formats natively. This breaks functionality for image-heavy modes, such as image-mode, viewing PDFs via pdf-tools, or displaying mathematical LaTeX previews.
• --without-imagemagick Prevent Emacs from using this large dependency for complex image transformations. You lose the ability to perform advanced image manipulation (like dynamic resizing or rotation of certain formats) within Emacs buffers.
• --without-lcms2 Remove the Little CMS color management layer. Images may appear with slightly incorrect colors on high-quality displays, as Emacs will ignore ICC color profiles embedded in files.
• --without-xinput2: Disables the modern X11 input extension. Warning: If you are building for X11, disabling this will break pixel-precision smooth scrolling for trackpads and mouse wheels, forcing Emacs to use choppy line-by-line scrolling. This flag does nothing for Wayland/PGTK builds and offers no performance benefits.
• --disable-acl: Disables support for Access Control Lists. Disabling this reduces the number of system calls Emacs performs during file operations. This is a good choice for single-user systems where standard Unix permissions are sufficient.
• --disable-xattr: Disables support for Extended File Attributes. Only keep this enabled if you rely on SELinux or filesystem-level file tagging.
• --without-kerberos --without-pop --without-kerberos5 --without-hesiod --without-mail-unlink: These flags disable support for ancient mail retrieval methods, directory services, and local mail spool manipulation. Because modern Emacs mail setups rely on external synchronization, disabling these ensures the build script does not waste time searching for legacy network libraries and keeps the binary entirely free of dead mail code.

Step 5: Compiling the Source Code

With the configuration complete, the next step is to compile the C source files and the core Emacs Lisp files:

make -j "$(nproc)" -l "$(nproc --ignore=1)"

• -j $(nproc): This sets the maximum number of concurrent jobs to the number of CPU cores. Make will attempt to run up to the the number of CPU cores compilation commands in parallel. This is an upper bound; actual concurrency may be lower depending on dependencies and system load.
• -l $(nproc --ignore=1): This sets a load average limit. $(nproc --ignore=1) returns the number of available CPU cores minus 1. Example: on an 8-core system, this evaluates to 7. So effectively, -l 7 means: do not start new jobs if system load average is 7 or higher. Make uses system load average (typically 1-minute load average) as a throttling mechanism.

On a low-load system, Make may run close to 48 jobs in parallel. Under high CPU pressure, Make will throttle and pause scheduling new jobs until load decreases.

(Related article: Similar to make -j command above for Emacs compilation, read “Enabling Emacs native compilation and dynamically adjusting the number of Elisp files compiled in parallel“)

Step 6: Installing the Stripped Binary

The final step is to copy the compiled binary and its associated files to their proper locations on your file system.

sudo make install-strip

While the standard make install simply copies the compiled files, make install-strip performs an additional optimization. It strips debugging symbols from the final executable. Removing these symbols reduces reduces binary size on disk.

Verifying Emacs Build Features

After successfully compiling Emacs from source, execute the resulting Emacs binary.

Once the editor is running, it is good practice to verify that your desired features, such as native JSON parsing or tree-sitter support, were correctly detected and linked during the build process.

You can verify this by inspecting the system-configuration-features variable. To view its contents, type M-x describe-variable RET system-configuration-features RET, which will output a string detailing the exact libraries and features baked into your current executable.

Optional: Risky Emacs Optimizations

Risky Optimization: Replacing -O2 with -O3

NOTE: The Emacs developers strongly recommend against using -O3, -Os, and -fsanitize=undefined for ordinary production builds, stating that these flags are known to sometimes cause unpredictable problems with the generated code. (Source: The INSTALL file in the Emacs source tree.) That said, I have compiled Emacs using -O3 and have not experienced any issues.

Here is how to apply this optimization:

• Compiler configuration: Replace the -O2 flag with -O3 in your CFLAGS. (Avoid substituting -Wl,-O2 with -Wl,-O3 in your LDFLAGS, as the underlying GNU ld documents optimization levels up to -O2 for linker optimizations.)
• Emacs configuration: Replace -O2 flag with -O3 in the native-comp-compiler-options variable.

The theoretical benefits of -O3:

• Aggressive function Inlining: Function inlining speeds up execution by pasting a function’s code directly where it is called, eliminating the overhead of jumping to a different memory address.
• Loop Unrolling: Loop unrolling is a compiler optimization that copies parts of a loop multiple times so the program does not need to repeatedly check conditions like i < 10 as often. This reduces repeated checks and jumps, allowing the CPU to spend more time performing useful work instead of constantly deciding whether to continue the loop. This creates longer uninterrupted sections of code, which modern processors can execute more efficiently by processing several independent operations in parallel at the same time.
• Faster Buffer Processing (Vectorization/SIMD): For heavy text searching, such as complex regular expression matching or byte-level buffer manipulation, -O3 may allow the compiler to use special CPU instructions that operate on many bytes of data at once instead of processing each byte individually. For example, instead of comparing one character at a time, the CPU may compare 16, 32, or more characters in a single operation, which can improve performance in some workloads.

The tangible risks of -O3:

• Instruction Cache Bloat: Aggressive inlining copies large amounts of code directly into other functions, which can significantly increase the size of the final executable.
• Exposing Undefined Behavior: -O3 enables more aggressive optimizations that assume the C source code fully follows the rules of the C standard. In large and old codebases like Emacs, some code may accidentally rely on behavior that is technically invalid or undefined. When combined with Link-Time Optimization (LTO), the compiler can optimize across multiple source files and make transformations that expose these hidden issues, potentially causing random crashes, UI freezes, or unstable behavior.
• Mangled Stack Traces: -O3 aggressively rearranges and simplifies code to improve performance. Functions may be merged, variables may disappear entirely, and instructions may execute in a very different order than they appear in the original source code. If Emacs crashes, debugging tools such as gdb may produce stack traces that no longer clearly match the original program structure, making debugging substantially more difficult.

Using -O3 is an experimental optimization. If you experience out-of-memory build failures, random micro-stutters, UI freezing, or crashes, revert to a standard -O2 build with or without LTO.

Conclusion

Building Emacs from source and bypassing generic Emacs distribution binaries strips away decades of legacy compatibility layers and align the Emacs’ execution directly with your specific hardware architecture.

Remember to trigger a fresh recompilation whenever you update core system toolchains, such as GCC or your graphical compositor, to maintain binary compatibility and performance integrity.

Marcin Borkowski (mbork) has an interesting post on the describe-personal-keybindings command. The idea is that the command lists the keybindings that you have set in your configuration. It’s convenient, mbork says, for checking that new Emacs releases haven’t stolen one of your bindings. It’s also interesting to see what bindings you’ve added and what, if anything, they’ve replaced.

But there’s a catch. In order for a personal keybinding to show up, it must have been set with the bind-key macro. That’s a problem for those of us who are long term users. Those who use use-package exclusively have no problem since the :bind command uses bind-key automatically but bindings set with, say, define-key will not appear in the describe-personal-keybindings output.

That’s inspired mbork to refactor his init.el to use use-pacjkage and for stand-alone bindings, the bind-key macro.

The minions are insisting that I mention what they consider the best part of mbork’s post. That, of course, concerned dark mode. Mbork begins his post by mentioning a Web app that provides a Web based cheat sheet of Emacs commands. Mbork says it’s a cool command but not for him because

if I were to create something like that, it would run in Emacs and not in the browser, it would definitely mention transpose-.* commands, and it would never be dark-mode-only;-).

The minions haven’t been causing much trouble lately so I thought it only fair to indulge their desire to get mbork’s dislike of dark mode on the record.

I have used EWW in Emacs for some of my browsing for a while and it does the job very well unless browsing single page applications or other sites that do not send HTML unless you run JavaScript. Thank you Lars Magne Ingebrigtsen for making EWW! Hitting R filters out all the noise for a really pleasant reading experience. It is good to browse within Emacs with no context switching in a keyboard-driven way.

(Apropos they joys of context switching: When I am a bit tired, I use Emacs keybindings everywhere. Tap-to-click is naturally off on my laptops to prevent insanity. I am often able to "help" my students a lot within just a few seconds of random keybindings and clicking everywhere on their laptops. It is really good for students to learn patience and tolerance towards people unable to handle computers. They need that for their user support class and future work in the IT industry.)

When Joshua Blaise wrote about his eww setup and use, I read it with interest and stole most of his ideas for my own config. The important one for this little hack is that I set up URLs with endings like .mp3, .mp4, .m4v, .mkv etc to launch in mpv when browsing to them. This makes watching videos and listening to audio content easy with EWW. EWW is also good for browsing local files by hitting W with point on a file in dired.

In dired, I usually launch external programs for photo editing, media playback etc by pressing & with point on a file name. This brings up the completing-read interface in the minibuffer which asks me if I would like to use dired's guess as to which program to use (which I have set to guess xdg-open first) or something else. I press return and then mpv, gimp, darktable or whatever launches with the file.

I had an html file in my downloads folder which I launched with W to read in EWW. I then, by mistake, hit W when on a .mp3 file, and it launched in mpv. Since W launches the file in EWW and EWW was configured to open .mp3 files in mpv, it did that without asking me which program to use. It is faster to hit W than to hit & RET, or in worst case write a program name and RET. So now I launch media files with W in dired in stead of using &. It speeds things up a bit.

(While writing this, I also remembered that I have functions for playing enclosure links and links in elfeed through mpv that I might replace or improve by shuffling the links to EWW or einar-browse-url-mpv. I wrote my configuration for elfeed very early in my Emacs journey, without really understanding any of it, by copying snippets from the Emacs wiki, blogs and Reddit so it is high time to look at it again anyway. I can probably simplify it.)

Here are the relevant parts of my configuration for EWW to get this working:

(defun einar-browse-url-mpv (url &rest _args)
  "Opens URL in mpv."
  (start-process "mpv" nil "mpv" url))

(use-package eww
  :config
  (setopt browse-url-handlers
          '(("\\(youtube\\.com\\|youtu\\.be\\|vimeo\\.com\\|twitch\\.tv\\)" . einar-browse-url-mpv)
            ("\\.mp3$" . einar-browse-url-mpv)
            ("\\.mp4$" . einar-browse-url-mpv)
            ("\\.webp$" . einar-browse-url-mpv)
            ("\\.m4v$" . einar-browse-url-mpv)
            ("\\.mkv$" . einar-browse-url-mpv)
            ("\\.pdf$" . einar-browse-url-pdf)
            ("." . eww-browse-url))))

Those of us who have been around long enough remember Sacha Chua’s Emacs Chat videos. The last one was a decade ago but now that Chua’s daughter is a bit older, she’s decided to resurrect them. The first new episode, Emacs Chat 21, is with Amin Bandali with whom she’s worked on EmacsConf for the last 7 years.

The format is always the same. Chua and her guest discuss the guest’s Emacs configuration and how they’ve solved various problems. There’s way too much material for a quick recapitulation—the video is an hour and 12 minutes long—but there’s a transcript at the link so you can go through it at your leisure if you find the video’s pace too rapid.

There were a couple of things that I found particularly interesting. The first is the upcoming user-lisp-directory. It allows you to specify a directory for your Lisp files and Emacs will automatically compile them and add them to the load-path for you. Bandali uses it as a replacement for the package system because he prefers to configure things manually.

The second interesting thing for me was his use of EXWM (Emacs X Window Manager), which goes a long way towards the dream of bringing everything into Emacs. I’ve long wanted to try it out but as its name suggests, it works with the X-Windows system only. The Irreal bunker has famously standardized on Macs so EXWM is unavailable to us. I’d still love to try it though.

There’s a lot of material in the chat so you’ll have to watch it—or at least skim the transcript—to get the whole picture. There are links to his configuration so you can steal anything that seems useful to you.

I’m really happy to see Chua resurrecting her Emacs Chats. I really enjoyed the previous ones and learned a lot from them and I’m sure that will be true of the new ones too.

I've done a small update to make-phony.el, my little Emacs package that lets me be lazy when adding .PHONY to mark a target as a phony target in a Makefile.

The only change is a tweak to the regular expression, to tighten up the check for a target that can be marked.

last-rev.pl

As returning readers will know, I produce (or try to produce) regular builds of Emacs for Windows. When things work, these produce pre-compiled binaries as an installer and unpack-and-run zip files. You can find links to the latest set for each branch in the box at the top-left each page on the site.

Today's post is about one program out from the middle of the bucket-brigade of data I have created, generally in an effort to avoid unneeded queries of the upstream (Savannah or Savannah mirrors hosted) repositories.

Carrying on with the theme of being lazy while editing posts, I've released blogmore.el v4.5.0. This version adds blogmore-set-as-cover. With this, if you place point on a line that is an image and run the command, it is set as the cover for the post.

Sure, it's not like it's hard to copy, move, insert a new line, type cover: and then paste the text, but this is faster and more accurate.

And I'm lazy.

And I like hacking on Emacs Lisp that makes my workflow flow faster.

The shell-pop Emacs package provides on-demand access to a terminal buffer via a single, configurable key binding. It allows toggling a terminal window without disrupting the workspace layout, making it a useful tool for quick command-line tasks.

NOTE: Kazuo Yagi, the shell-pop original author, appointed me as a co-maintainer of shell-pop Emacs package. I recently refactored shell-pop to improve robustness, fix bugs, and add support for additional terminals (vterm and eat). Stepping into the maintainer role gave me the opportunity to give the codebase a thorough refactoring.

Why use shell-pop?

Adding shell-pop to your workflow offers the following benefits:

• Your terminal session remains active in the background, retaining your command history and running processes.
• It can automatically change the terminal directory to match the file or project you are currently visiting in Emacs.
• Toggling the shell does not ruin your carefully arranged window splits. (Especially when shell-pop-full-span is set to set to t)
• It supports a wide variety of terminal emulators (term, eshell, ansi-term, vterm, and eat).
• It provides control over the terminal window layout, allowing you to specify its exact size as a percentage, define its position (top, bottom, left, right, or full screen), and choose whether it should span the entire width of the frame.
• It handles cleanup gracefully by automatically killing the terminal buffer and safely deleting its window when the underlying shell process exits.
• It includes a comprehensive set of lifecycle hooks (for opening, closing, and exiting), allowing you to trigger custom Emacs Lisp functions automatically based on the terminal state.

Installation and configuration

To install shell-pop from MELPA:

1. If you haven’t already done so, add MELPA repository to your Emacs configuration.
2. Add the following code to your Emacs init file to install shell-pop from MELPA:

(use-package shell-pop
  ;; :bind automatically sets up the keybinding AND tells Emacs to lazy-load the
  ;; package the moment the key is pressed.
  :bind (("C-c t" . shell-pop))
  :custom
  ;; The key sequence used to toggle the shell window.
  (shell-pop-universal-key "C-c t")

  ;; Sets the screen position where the shell popup appears.
  ;; You can choose "bottom", "top", "right", "left", or "full".
  (shell-pop-window-position "bottom")

  ;; If non-nil, the window stretches across the entire frame width.
  (shell-pop-full-span nil)

  ;; The path to the shell executable used by the terminal emulator
  ;; (e.g., "/usr/bin/env bash").
  (shell-pop-term-shell shell-file-name)

  ;; The height or width of the window as a percentage of the frame.
  (shell-pop-window-size 30)

  ;; Setting this to non-nil sends commands to the shell. This is not always
  ;; desirable, as it can send commands to any prompt.
  (shell-pop-autocd-to-working-dir nil))

Configuring the terminal

Here are the exact configurations for the most popular Emacs shells. Simply copy and paste your preferred option into your init file:

ansi-term

(with-eval-after-load 'shell-pop
  (setopt shell-pop-shell-type '("ansi-term" "*ansi-term*"
                                 (lambda ()
                                   (ansi-term shell-pop-term-shell)))))

term

(with-eval-after-load 'shell-pop
  (setopt shell-pop-shell-type '("terminal" "*terminal*"
                                 (lambda ()
                                   (term shell-pop-term-shell)))))

vterm

Note: Requires the vterm package to be installed.

(with-eval-after-load 'shell-pop
  (setopt shell-pop-shell-type '("vterm" "*vterm*"
                                 (lambda ()
                                   (when (fboundp 'vterm)
                                     (let ((vterm-shell shell-pop-term-shell))
                                       (vterm)))))))

eat

Note: Requires the eat package to be installed.

(with-eval-after-load 'shell-pop
  (setopt shell-pop-shell-type '("eat" "*eat*"
                                 (lambda ()
                                   (when (fboundp 'eat)
                                     (eat shell-pop-term-shell))))))

Enhancements that I implemented as co-maintainer

If you are a long-time shell-pop user, here are the changes I recently made to the package. I encourage you to try the latest version and send Kazuo Yagi and me your feedback in the issue tracker:

• I added support for the vterm and eat terminals, two highly requested modern terminal emulators. This includes implementing automatic directory synchronization to ensure the shell always matches the current working directory in Emacs.
• Previously, the package relied on global variables and buffer deletion to manage window states. This caused unpredictable behavior when using complex layouts, multiple frames, or tabs. I refactored shell-pop to isolate state tracking by attaching it directly to Emacs window parameters.
• I resolved issues related to zombie buffers and asynchronous window hijacking. The code now stores buffer objects instead of names, scopes process sentinels strictly to the shell window, and correctly verifies buffer lifespans before attempting restoration.
• The toggle functionality now correctly recognizes active shell windows even when the cursor is focused elsewhere in the frame, preventing redundant terminal pop-ups.
• I fixed a directory desync bug by unconditionally enforcing auto cd. Emacs will no longer lose track of the shell’s actual working directory if a user manually changes directories inside the terminal.
• The teardown routines were adjusted to ensure native terminal cleanup processes, such as writing Eshell history, execute fully before the buffer is destroyed.
• I replaced the simulated Ctrl-L keystroke with an explicit clear command to prevent literal ^L characters from printing in the terminal input buffer.
• The hard dependency on the term package is now optional. Users who prefer vterm, eat, standard shells or Eshell are no longer forced to load unnecessary terminal packages on startup.

Conclusion

Taking on a maintenance role for a tool I use daily has been an interesting experience. These recent updates aim to make shell-pop more reliable and modern. I encourage you to try the latest version and send us your feedback.

As I mentioned a few days ago, the Emacs 31 release process was on the verge of starting. Now Sean Whitton writes to tell us that the Emacs 31 branch has been created and that the feature freeze has begun.

This means that the Emacs 31 release cycle has begun and that’s what on the Emacs 31 branch is pretty much—modulo bug fixes and last minute emergency additions—what the final release will be like.

The release cycle—if you believe in history—is apt to be long but even though that can be frustrating it means that the final product is going to be rock solid.

Although I keep repeating it, I can’t say it enough: thanks to all the developers who selflessly donate their time and efforts to making and keeping Emacs one of the best—if not the best—editors available.

In the recent weeks I've been engaging Prot as an Emacs coach to help with doing review passes over my upcoming ffs package as I work on polishing and documenting it in preparation for offering it for inclusion in GNU ELPA.

Yesterday we had our second session focused on ffs, which I recorded and share publicly with everyone with Prot's permission, so that others can also benefit from Prot's insights and experience as we discuss various aspects of Emacs package development with the concrete example of ffs.

Here is the video recording of our session:

You can view or download the full-resolution video from the Internet Archive.

I addressed most of Prot's feedback about ffs from our first session, and I'll be working on the changes we discussed in this session in the next days.

In the last third of the video we switched topics to discuss a few Emacs-related tangents including adding a 'padding' effect for the mode line and its constructs, and distilling and separating the easily-reusable package-like parts of one's Emacs configuration from the actual configuration of those parts (e.g. the distinction of prot-lisp and prot-emacs-modules in Prot's Emacs configuration).

For mode line padding, here is the snippet I'm using with Prot's doric-themes:

(doric-themes-with-colors
  (custom-set-faces
   `(mode-line
     ((t :box (:line-width 6 :color ,bg-shadow-intense))))
   `(mode-line-inactive
     ((t :box (:line-width 6 :color ,bg-shadow-subtle))))
   `(mode-line-highlight
     ((t :box (:color ,bg-shadow-intense))))))

Take care, and so long for now.

I met with Amin Bandali to talk about Emacs, specifically Amin’s upcoming ffs package. Amin informed me about changes to ffs in light of a discussion we had during a previous session.

Amin asked me to record the meeting and then publish it, which I happily agreed to. You can watch it on Amin’s website: https://kelar.org/~bandali/gnu/emacs/ffs-code-review-prot.html.

[ NOTE: I normally do not share anything about my meetings with people. Not who they are nor what we talk about. ]

Thanks to Amin for making this happen! I am looking forward to new developments.

By the way, I learnt about the function x-export-frames from a mention in Amin’s ffs package, which led me to write buffer-to-pdf: https://github.com/protesilaos/buffer-to-pdf.

I chatted with Shae Erisson about Emacs, keyboards, Org Mode, and life.

View it via the Internet Archive, watch/comment on YouTube, read the transcript online, download the video / MP3 / transcript, or e-mail me your thoughts!

• Shae Erisson: Haskell, Python, Swedish, knitting, mountain unicycling, contact juggling
• Shae Erisson's blog - 1. DO SOMETHING 2. BRAG ABOUT IT
• Shae Erisson (@shapr@recurse.social) - recurse.social
• Shae Erisson's blog - Programmers want flow. when programming, light turns RED
• shapr/markovkeyboard: keyboard layout that changes by markov frequency · GitHub

Transcript

Transcript

0:00 Intro

Sacha: Okay, so I'm going to actually remember to hit go live. I've got a 10 second delay, so if we need to panic, we can panic. Okay, so let's see. I think we are live. Hi, everyone. This is Emacs Chat number 22 after a long hiatus. And today, I'm here with Shae Erisson, who is also like an Emacs friend from a long time back. So this is it. As you were just saying, this is the first time we're actually talking live. And I'm looking forward to hearing about your configuration, how you use Emacs, Shae. But before we dive into that, can you give us a little bit of context? Who you are, what sorts of things you do, and how you use Emacs for that?

0:57 1999, IRC, community building in Haskell

Shae: I would say that... I guess I started using Emacs in 1999 when I moved to Finland. And I remember about the same time I was on IRC and I was really frustrated. I remember I got on the Perl IRC channel and I was like, hey, I want an editor that has syntax highlighting. I want to see colors to these words when I'm typing them. And they were like, noob, and they kick-banned me. And I was like, well, maybe I don't want to learn Perl, which I never did. And I guess that was an early introduction into I wanted to be part of communities where people were sharing positive things and building up each other. Actually, I ended up starting the Haskell IRC channel a couple of years later, and that became a very big thing. I would say that I'm mostly known for my work in community building in the Haskell programming language community, because I did that for, I don't know, 15 or 20 years. But I really like Emacs.

1:58 Emacs as a light-weight build-your-own-editor toolkit

Shae: So like last week at the same time I had the standing chat with a friend of mine who is also a programmer and he said oh so you're going to do this thing in a week do you want to give me like a preview of the talk and I was like yeah I guess so and some of the things that were really interesting was he was like I've never really tried Emacs I don't know much about it I kind of have this impression that it is a very lightweight build your own editor toolkit and I I was kind of taken aback because, you know, I guess I still have this long ago and far away. I don't know if you remember 8 Megs and Constantly Swapping is what people used to call Emacs and things like that. And I was, it was just kind of, I realized I'm still in my little echo chamber. And this is why I like to talk to other people all the time is because I want to have some exposure to what other people are doing.

2:51 LSP, treesitter, Magit, jujutsu, C++, Python, Haskell, rust

Shae: I guess things about Emacs that really changed stuff for me is language server protocol, TreeSitter. Those, I think, are two very powerful tools that are much more generic than, I mean, Magit, of course, is like magic. Although I've mostly switched to jujitsu lately instead for the last year. Let's see, I had, I guess, let's see, I did C++, I did Python, I did a whole lot of Python. And then I had Haskell jobs for five or six years. And then I switched to Rust about a year and a half ago. I now have a Rust job. And one of the things that Prot had asked, I think, or you had asked, and I forget exactly how this went.

3:35 how does a new person experience Emacs? Emacs is always fun.

Shae: It was great fun watching your livestream. And it was, how does a new person kind of get comfortable with using Emacs for a particular purpose. And I look for things, in fact, like how do I use Emacs for Rust, Rust development? And I found a couple of good guides on, and I was able to follow most of them, although my Yesnitit stuff is broken and I don't exactly know why tab doesn't work, right? But, you know, like there's always, Emacs is always fun, right? There's so many cool things you could do with it.

4:03 Markov keyboard project, moving to Finland, right-handed Dvorak, split keyboard; Jeff Raskin; I am not a koala

Shae: I noticed, I actually hadn't seen your preview page and I noticed that you found my Markov keyboard.

Sacha: When you say Emacs is fun, I'm reminded of all of your fun, crazy keyboard experiments. It's like, what? I have a feeling you like to tinker with things.

Shae: Yeah, so I think actually the influences as to how I got to where I am are pretty interesting. So the person that I ended up moving to Finland to for dating her, we started a company, we did projects, and I was the programmer. We had this pretty big project. I guess it was like 350,000 euros. And I mean, that was going to be over four years and we had to kind of complete the whole thing, and I was the programmer and we'd had the lowest bid... I had an IBM model M, you know, the super clicky with like all the... And about three years into it, my arm started really hurting a lot. But I was the only programmer. And nobody else knew all the code. And we had to ship it, because that's how we got paid. And so I ended up pushing through. And at the end of it, my arm just didn't work anymore. So for about a year and three months, what I did was I actually taught myself to type right hand. ...Dvorak, because I was already using two-hand Dvorak, and so I kept programming, but I just... One of the things was... like, I like programming, I like using computers, I don't want to wear out my arms again, I don't want to blow them out, so I ended up switching to split keyboards, and I will show you. This is very much the kind of thing that I like to use, and that is like this.

Shae: This is an Ergodox Infinity, but there's a lot of other keyboard flavors like this. And one of the things that I particularly like about this... So around the same time I met Jeff Raskin, who wrote the Inhumane Interface. And so for this particular thing, this is like Control and Alt and Hyper and Super and Shift. And this means that under one thumb, I have a lot more modifier keys than you get off of a standard. And it also means... A lot of my problems started with Emacs pinky, the dreaded, the infamous... I think that one of my... I made a keyboard layout called "I am not koala." You may not know this, but koalas have two thumbs. They have one on each side. And that's cool, but I don't have two thumbs, and I realized that when I was trying to grab something, I didn't put my pinky on it. That would be silly, right? I want to put my thumb around it. And so I decided I would move all of my chording keys under my thumbs. And that's kind of how I...

6:43 Purpose-specific function keys

Shae: And another thing I did was when I was really only able to use one hand, was I made my function keys mostly purpose-specific. And that was from Jeff Raskin's writings in The Humane Interface. So I guess I'm a programmer who really likes writing code, doesn't want to wear out my arms, and likes to do fun keyboard things, yeah.

Sacha: Definitely. You're in it for the long term. You don't want to use up all of your arm capacity now and not be able to keep programming in the future. And now there's hardware to make that easier. So I'm glad. Split keyboards with extra thumb keys seem to be very popular in the Emacs community. I'm now tempted to find space in my desk in order to make that happen.

7:30 Trackballs, scroll

Shae: Another thing I ended up switching to was I started using trackballs. Oh yeah, yeah. I tend to go completely overboard when trying out new things, so I bought 20 different models of trackballs and ended up settling on this one. The nice thing about this one is that this is how you scroll, and it has four buttons.

Sacha: That is really cool. I like using ThinkPads, so I've been just living off the tiny little mouse in the middle of the keyboard. But back in the day, I also used a trackball. If I can get to the point where I want to take my hands off the keyboard again in order to do mouse things, that would probably be the direction I would go.

8:14 1" trackpad rings

Shae: I had an experiment in that area, which is where I purchased a one-inch touchpad, and I strapped it to my finger. And it was a PS2, and it had a USB converter plugged into it. And the idea was I could keep typing, and then I could move the mouse around without taking my hands off the keyboard. And now they actually have touchpad rings. They came out six months or a year ago. It's relatively recent. But the idea is no change in context.

Sacha: I've only seen the scroll rings, but now there's a touchpad version. That is interesting.

Shae: Yeah, I think that's pretty cool stuff. Hardware is actually improving things.

8:54 Pair programming: ttyshare, shwim

Shae: Oh, another thing, one of the things you talked about with Prot was how do you learn other people's stuff? And one of the things that I use for pairing, so I have one coworker, and it's a strange, interesting job. I like it a lot. And I met this coworker at a previous job, and one of the things, let's see if I can find it. So we used to, at the previous job, we used this thing called ttyshare. Have you heard of it? ttyshare. It's great. You can run it in a terminal and then you can effectively share your terminal with someone else. And so you have multiplayer terminals and that's neat. It was kind of a pain to set up. You had to make sure that you weren't NATed, you know, like you had to have effectively... someone had to have a public IP. You had to do a couple of other things. And as part of my job, I'm now, I guess, part maintainer for Magic Wormhole, the software.

Shae: And so one of the things that my coworker wrote was this nifty thing called ShWiM. And it's basically "shell with me." And it's a wrapper around TTY share so that with one single command, you can share a terminal. And the way that we use this is... We both run Emacs as a server, and then we use emacsclient in the terminal to connect.

Shae: I don't know if you've ever done this, but I can have a terminal right next to this, and if I run emacsclient in a window, then I'm sharing the same thing. This is a graphical chat with Sacha, in the terminal or in the UI, and both of them are updated.

Sacha: That's fantastic. I remember people were using tmate for something similar before where you could share that. But yeah, it's just making it seamless, making it frictionless. And on the other side, I have also just been using wormhole to send large files back and forth between Karthik and John Wiegley because we have this other Emacs chat thing where we're going to post it eventually, once I finish figuring out how to redact all the personal information and Org files. But yeah, it's great for being able to send things without having to worry about, oh, you know, what's my public IP? Can I tunnel all the different things to get past whatever firewalls there are? So if this also works for terminal things plus Emacs client, that sounds really, really exciting.

Shae: We've tried some other experiments. One of the things we tried to do was, and the only downside is like, what if my terminal has a different size, then you have to kind of shrink and match. And so we tried to honestly directly bridge to Emacs clients. And because I don't know if you're aware that there's effectively a local socket for the Emacs client that you can have multiple things connect to. But it turns out there's some sort of like system so I couldn't like reach across the network and directly use my co-workers Emacs session and he couldn't use mine. Weird things happened when we tried to do this cross host. As far as I can tell the Emacs client only works in the same host.

Sacha: That's interesting. Lately, I've also been experimenting with CRDT, which has that Emacs-less plant as well. So that's been nice. But yeah, of course, a lot of people will be kind of stuck with the first challenge of finding someone that they can pair in Emacs with.

Shae: I understand. And I think I'm honestly very happy that my one single coworker at this job is also a big Emacs user. And so we exchanged cool ideas and worked on stuff. And I'm very happy about that.

Sacha: Were they already an Emacs person before they joined? Or did you pick the coworker because they were an Emacs person?

Shae: They picked me. They were pretty much the person who started this thing. And they picked me because they'd worked with me at the previous job. Although I did have an experience like that. I had this massive Emacs config file, like 20,000 lines, and half of it was comments because it had accrued over 20 years.

13:13 Recurse Center, "What is that keyboard? What is that editor?!", Emacs bankruptcy and starter kits

Shae: And in 2019, when I first went to the Recurse Center, well, my first batch, I just was extremely extroverted and social. But my second immediate following batch, which is not the common pattern, I was like, okay, my goal is to write a bunch of Haskell, get some Haskell jobs, And so I went to the quiet room on the quiet floor. But then someone else came in, Marianne, my favorite programming friend. And she was like, what is that keyboard you're using? And I was like, ah, this is an Ergodox thing. And then she's like, what is this editor you're using? And I was like, oh, that's Emacs. And I was kind of a grumpy, like, I'm trying to get stuff done. But she was persistent. She was like, show me this thing. And so I was like, I'll show you Emacs. And she was like, this is great. And I was like. This thing? OK, cool. And I was like, I don't think you want my config. You'll probably want a starter kit. And she was like, well, what are starter kits? And I was like, well, I've heard about Spacemacs. I've heard about Doom. And I would try one of those. So she tried Spacemacs. And I guess this next part happened over several months. She tried Spacemacs. And then she was like, I like it, but it's slow. So I'm switching to Doom Emacs. And I would pair with her. And I was like, wow, look at all these cool things that the starter kits can do. I ended up flushing my entire 20-year-old config and kind of starting over and stealing a lot of great ideas from the starter kits. And Marianne is very ambitious, independent, hardworking, very focused. I'm not very focused. But I've learned a lot of things from her and watching her kind of... I haven't done C in Emacs in a long time so it's great fun to watch her learn these new things and then I learned stuff too and yeah it's good to have collaborative people to work with.

Sacha: So it sounds like if people would like to encourage more people to talk to them about Emacs, feel free to use your strange keyboards out in public.

Shae: I like that. That's good. That is good. Yeah I think that's reasonable.

Sacha: Yeah, and I've just recently started digging into the starter kits too, because I realized I don't know much about them. It is really interesting going through them and discovering all these Emacs 31 options that you can enable to simplify your config or improve your workflow and all that stuff. So there's a lot of good stuff in starter kits, even for people who are not newcomers.

Shae: I agree. And I think there's nothing wrong with just learning a bunch of new things, trying them out, and also throwing them away if you don't like them.

Sacha: Now that you've declared Emacs bankruptcy and rebuilt your Emacs on top of other people's starter kits, what has made it into your config? What have you kept from those 20 years of tinkering with Emacs that you really wanted to stick around?

16:06 hippie-expand

Shae: I think the only thing that has absolutely stuck around is my use of hippie-expand, which is, I believe, a very old... an ancient tool from a different time. Most of the other stuff is kind of gone. Gone to the wayside. But I really like, I honestly really like hippie-expand. And I know that like, I have rarely heard of other people who use hippie-expand. But you use it? I think you just muted yourself.

Sacha: I also vote for hippie-expand. It's a nice way to try different functions and just say, I just want all these different possible completions to go in there.

Shae: Yeah. The thing for me that really sold me on hippie-expand is that most of the time when I am... When I'm doing something, I want to say, like, I can already see that word, just pick that one. And so I'll type the first characters and hit, like, meta forward slash, and ta-da, it's usually there. But then sometimes I do really want, like, some Elisp or some other stuff. And so I actually spent a lot of time tuning this the first time.

17:14 yasnippet

Shae: I actually only changed it for the first time recently because I was reading a how to write Rust well inside Emacs and they said oh well you want to use yasnippet and so I you know the funny thing is that yasnippet I believe is the thing that got me into Emacs like in 1999 I met this Finnish person Erno Kuusela in Oulu, Finland. Really cool guy. I was like, wow, how do you do this? As soon as you open a file, it's got a substructure and a skeleton. And when you type part of a function or something, it just populates it. And he was like, I'm using this snippet command in Emacs. That's why I was like, what's Emacs? It was very exciting. And at the time, I was using Vim. And Vim was not as, I don't want to say, automatable.

Sacha: Yeah, now with Neovim and Lua, people are writing more extensions for it. But before, you had to know a lot of magic in order to customize Vim.

Shae: Right, right. I agree. Let's see, what else do I do? I run my own email server, and I, of course, read my email in Emacs. In GNU, no less. Which is, I know, an NNTP reader, but it's still also a great... I used to use twiddle compile and I think that stopped working like six years ago, so I need to get rid of this comment, but there's still a lot of kind of cruft from earlier times.

18:52 Function keys

Shae: Remember how I said that I use function keys to have like purpose specific stuff? This was especially true because, I mean, I had my left arm strapped to my chest for like a year and three months before I even started regaining any flexibility, and that meant that... I'm amazed that you could just map them directly to single commands instead of giving in to the temptation to make them prefixes for longer keystrokes. I didn't really have the choice because I had only one arm that worked. It was just a lot harder to do any chording at the time. I still have a lot of these. F3 I use a lot, which is like, oh, what am I working on right now? That is org-clock-goto. A lot of times, I want to have a terminal that's in Emacs, so that's vterm,

20:02 Org Mode

Shae: And I actually really do use the calendar all the time. This is like just switch to whatever it is. Of course, my email is here. You know what, let's see... So this... I don't know, have you seen this before? Have you seen this thing called STARTED in an Org mode file?

Sacha: I use a STARTED state, yes.

Shae: Well, I got it from you! So if I look at like, my Org Mode configuration, a lot of this STARTED stuff I have from you, I don't know when, but you were the person who introduced me to it.

Sacha: It's the reminder that I did start working on this. I tend to get distracted by intermediate tasks, so it's nice to be able to say, try to finish these ones first before you move on to the next thing, maybe?

Shae: I agree. I have the same thing, yeah. And I keep meaning, because this is... I know that you can put Org Mode configuration into the first TODO item. I would really like to move it into the elisp and I just haven't gotten around to it. And it's been 10 years. I mean, maybe I should just do it.

21:14 Show Org agenda when idle

Shae: One of the things I did that I found fun... I really have written almost zero Elisp, but I did actually puzzle my way through this a year ago. Since so much of my life is in Org Mode, I learned how to make timers. This is very close to what you get directly out of how to do timers in Emacs. After some amount of time, I want my Org agenda to pop up because I want to say like, oh, what is the stuff I'm supposed to be doing? And what am I forgetting? What has been scheduled? And what is on my to-do list? And I also like to look at what is the stuff I've been working on lately? And I really like that a lot.

21:58 Programmers want flow. When programming, light turns red

Shae: Another thing that I realized is that I had a blog post that was wildly popular. Where did I put it? And it was all about Emacs. I don't know if you saw the... Here we go. It was... Ah, here it is. So here it is in... This is very much an Emacs...

Sacha: Oh, yeah, I remember that one. I put it in Emacs News. I thought it was great.

Shae: All right, cool.

Sacha: I would like the kiddo to sometimes be able to acknowledge this, but this is not happening. Still, yes.

Shae: Right, right. Yeah, and so this was really fun because, like... I had a friend who was in development and there was like millions of dollars spent on how do you detect whether a programmer is in flow and it came down to if they're typing they're probably in flow so and that was it because they tried to look at EGs and doing all kinds of other stuff but it was like if they're typing don't interrupt them. And I don't know, because I do so much in Emacs, I'm not sure how accurate this was. But basically, that's where I learned to do timers the first time. Or maybe... I don't remember which one I did first. And the idea then was as soon as basically my average typing into Emacs has gone up a certain amount, then it will actually switch to busy. And it works just fine. It was a lot of fun to write.

Sacha: So yeah, interesting use of getting the activity. I've seen other fun implementations of this. I think there's a c-c-c-combo package that makes some fun animation appear if you're typing really quickly.

Shae: Oh, oh, yeah. I'm guessing because I think Atom, the Atom editor had that for a while. I guess that's where it came from.

Sacha: So yeah, because you can instrument Emacs and play around with it, you can certainly do all sorts of things based on that information. Okay, so you've got it, you've got it set up so that when you come back to your computer, it'll show you the stuff that you've been working on. And when you're working on the things, you can tell it to tell the rest of the world not to bug you. Gotcha.

Shae: That's right. [Sacha: What other fun stuff do you have in there?

24:25 ef-themes and modus-themes, season

Shae: I discovered that I love the EF themes. I love the Modus themes. They make me very happy. They're just unreasonably pleasant. As someone who has tried every single Emacs theme ever, they're just my favorite themes.

Shae: And so, at the moment, it's summer... Where did my summer go? How can this be? There we go. How come I'm in spring? Wait, isn't spring over? Hasn't summer just started? You know what I was thinking would be fun would be take the time of day, and you know that the EF themes has spring, summer, autumn, and winter, and I'm not sure if there are dark versions of each of those, but I thought, like I know that Modus themes will do this like check for the local time of when it turns dark, and then it will go from the light theme to the dark theme as soon as the sun hits, and I was like, well, what if I do that for seasons, you know, wouldn't that be cool?

Sacha: There's this subtle sense of change as you go through the year. But of course you also have this thing there where you just randomize it.

Shae: Well, I like that. Sometimes it's like I'm just kind of like, ah, I'm bored. I'm just bored of what I'm looking at. And so I will just change my thing. And it's just time for something. I don't know. It seems to work. It's like it gives me a little brain break from what I was staring at. And I did not know I was going to reset the effects scale, but that's fine. Interesting. What else do I have in here?

25:56 htmlize (does this still work on Wayland?)

Shae: Oh, Emacs HTMLize. I'm a little sad. I switched to Wayland. And if I remember correctly, HTMLize only works with, or maybe HTMLize still works, and it's the SVG one that doesn't work. Emacs SVG is a thing that if you're running with an X11 backend, you can turn your current screen directly into an SVG, which is really cute. It does not work in Wayland. I think HTMLize does still work. What other things do I have in here? I don't know. I guess a lot of it lately has been trying to make Rust things work smoothly. I've been trying to do some... I wonder does... Oh, cool. That was not what I expected.

26:37 lsp-ui-imenu, jumping through rust code

Shae: I just started doing this thing with imenu. imenu integrates nicely with LSP.

Sacha: That is a very pretty sidebar thing, and I need to learn how to do that.

Shae: So because I have all these extra modifiers, my s-i is lsp-ui-imenu. And the reason that what I mostly use that for is when I have like a bunch of Rust code and I want to quickly jump through the structure of it. Basically that integrates with LSP, finds all the definitions, and I can quickly jump through it. I used to use lsp-treemacs for that, but lsp-treemacs puts things in its own order, not quite the same order I want, although treemacs is quite nice. I think that the thing to do is that you and I at some time maybe the next time if we do this again we should set up with a Shwim connection and you and I can both share our Emacs and then you can show me cool things that you do and I can show you cool things that I do and then we can start filing over some of the things. How about that?

Sacha: That sounds fantastic. I know we'd wanted to experiment with pair programming a long time ago so that sounds like a seamless way to do it. And therefore I will go and figure out how to install shim and get it working. I will probably need your help to actually test it. I don't know, I think I can rustle up. Maybe it'll work off my phone. You haven't tried that. But lspui, okay, so I've just been using straight up imenu, like on Neanderthal, but lsp-ui has this fancy grouping of things and colors and stuff, so I definitely want to check that out.

Shae: I'm a fan, yeah. I don't know. Do I have anything else exciting that goes with this in here?

28:25 laptop with 126GB of RAM

Shae: I will say that at the moment, the system I'm working on, I like buying unreasonably powerful laptops. And so, like, this system has 128 gigs of RAM and 24 cores. My previous laptop has 192 gigs of RAM. Long story short, I end up in a lot of cases where I want to use more memory. I've got all these cores. Can you do something with them? Perhaps you've already seen things like LSP doctor, which will say, have you tried this thing? Have you done this other thing? LSP has really changed

Sacha: I have not. Sorry, would you like to show me this LSP doctor thing? Because I have not ever seen it.

Shae: Yeah. Do you use language servers much for your development?

Sacha: I am only just getting used to having a relatively modern 2018 instead of 2010 laptop. And so I have the red squigglies and various things, but I don't know what to do with them yet.

Shae: Well, I mean, I'm doing a lot of this. So I have...

29:46 LSP coolness, Haskell, treesitter

Shae: Originally for me it was like I spent a lot of time with the Haskell language server because I was doing so much Haskell and it was a super powerful thing. In fact, somebody decided to hammer in half of a proof assistant into the Haskell language server and that was magic. You could do incredible stuff with that because you could just grab all of your local variables and transform the whole shape of your function and you could just write little snippets and just have it work. And that was amazing. It wasn't quite... One of the goals that I believe is... For future development of all programming editors, I believe that something like Emacs macros, but instead for abstract syntax trees, I believe this is an essential ingredient that we do not yet have. And I think that TreeSitter is the first step towards there. We now have one of the hats, right? Which is where we can take... TreeSitter is, you know, if you've used it... It is like you write some effectively C code to produce a really fast parser. Or is it like JavaScript that then compiles to C code? I forget exactly how it works. But the nice thing about TreeSitter is, I don't know if you remember, I'm sure you do remember, that if you were writing Python code and you used a triple-quoted string, you had to then add a comment with another quote because regular expressions is how Emacs was doing all the syntax highlighting. And honestly, that was kind of crap. And then there were projects like the Semantic Bovinator that made a full parsing suite in Elisp, which to me is half brilliant and half insane. And then there was TreeSitter, which kind of took over the world because it was... I think that the language server and TreeSitter are the first two of these editor generic pieces, and I suspect there will be more. I think that something where you can modify the abstract syntax tree and then put back to the source is one of those potential paths forward. I hope so.

Sacha: Yeah, that would be great if you could just do the manipulations and then roundtrip it back into source code. Just regenerate the changed part of your code. That sounds fantastic. So it sounds like you were able to do some kind of manipulation with the Haskell use case that you were describing. Any chance you can show us like the awesomeness?

Shae: Sadly, that sadly does not work anymore.

31:58 Combobulate

Shae: But you know, if you're looking for something in that area, have you heard of a Emacs library called Combobulate?

Sacha: I have heard of it. I haven't dug into it.

Shae: So it uses TreeSitter for source code manipulation by, and it's a lot closer to the way that like, you know, in Org Mode, you can like hold meta and arrow to kind of move things around. It uses TreeSitter to let you both move around in the context as well as actually alter the shape. And to me, this is the first step towards this tool that I want, which is where I can write a keyboard macro and have it edit an abstract syntax tree and then spit the results back into the buffer. Yeah.

Sacha: All right.

32:46 What else are you using your 126 gigabytes of RAM for?

Sacha: What else are you using your 126 gigabytes of RAM for?

Shae: Let's see. Honestly, I'm going to tell you that Rust Analyzer can take a lot of memory. And a Rust compilation can take a lot of cores. And I'm okay with that because I actually, I do like, and I will say that this laptop is actually from this year. So it's a brand new, like, top of the line. But then like, how would I, because I've got like, which I think is a bunch of matrix multiplication hardware. How do I use that from Emacs? I don't know. I'm sure I can find something, you know.

33:25 TalonVoice

Sacha: Maybe voice computing?

Shae: Oh, that's an idea. Yeah, one of my friends, she's using Talon. Have you heard of Talon?

Sacha: Yeah, I've heard of Talon. There are a couple of videos about people using Talon to code by voice, usually involving memorizing kind of a different alphabet for very quickly accessing different shortcuts. But it sounds really cool, and you sound like you've got the hardware to do something amazing with it.

Shae: That's true. Well, you know, Talon actually lets you do something very similar to Combobulate, where you can navigate the AST of your source code. You can kind of move around very quickly. I don't know, like, are we like at the end of our? No, no, we're halfway through, right?

Sacha: We're halfway through. I have about 28 minutes before the kiddo runs out and starts demanding lunch.

Shae: Okay, well, I feel like I've been driving the structure of our just kind of like dumping random things. Did you have any questions or anything you wanted to cover?

Sacha: This is all amazing. I come in with no preconceived notions. I'm just like, okay, shapr does cool things with Emacs. Let's hear about it. Let's go, let's go.

Shae: That works for me. Yeah. I mean, a lot of it's been focused on Rust development lately. Rust and Jujutsu.

34:45 NixOS, following Steve Purcell about 5 years behind

Shae: I've been doing a lot of Nix. I'm running NixOS. I don't know if you're familiar, but that's been great fun. It's funny, I feel like I've been following Steve Purcell around from a technical perspective. I'm always about five years behind Steve.

35:03 envrc

Shae: I was like, oh, you know, NixOS is kind of a pain with Emacs. And just like this, what was it, NixOS? I forget. Anyway, Steve was like, oh, well, have you tried my library, envrc? And I was like, what's that? And he was like, well, now each buffer can have its own envrc. And I was like, it's perfect. That's exactly what I need. Because previously, every time I switched buffers, it would then go load all of the local everything in Nix. And sometimes that could take a long time, especially if I'm doing Haskell, that could take 10 seconds, and I really don't want that sort of lag. And so Steve Purcell's brilliant library, envrc, says, you know what? Every single buffer can just keep such a thing, and then you can only relit it when you need to. And that's pretty awesome.

Sacha: That sounds cool, and I should check that out too.

35:52 time-tracking

Sacha: @JacksonScholberg has a question. He says, "I was curious about what you were tracking your time working on, how you track it." Is it just Org Clock? So this is how you keep track of the things you're working on and what got interrupted by the new thing that you just added to the stack and so forth?

Shae: Right. In fact, I have this thing. Honestly, when I sit down on my computer, Just clock in. You'll notice in the bottom right here, we have chat with Sacha, right? And so like, I just kind of clock in stuff. And like, I'm not always, I really kind of need to reorganize my Org mode files because I've been naming them per host because I previously had like a work Org mode and I had a home Org mode. now that my home hardware is also my work hardware I guess and so like I still have my previous laptops things where I'm keeping my events I really need to reorganize things but I mean yeah I schedule things I oh you know I've got a weird thing to show you

37:01 taxes with Org Mode, remote lookup

Shae: I decided that it would be great fun to do my taxes.

Sacha: You are showing me your taxes, do I need to like black out this whole thing?

Shae: Well, this is actually just an example from the docs. So I could actually share my taxes on it because I mostly don't care. But I think in fact you can figure out exactly how much money I'm making by looking at the open whatever. So the thing about this is that I decided to file all of my tax forms directly into Org Mode spreadsheets and then do remote lookups. So basically each spreadsheet was one particular form. And then once I'd gotten to the bottom, like I need this result, like what's my estimated income? And then I would use the lookup, kind of this cross spreadsheet lookup. And that's how I did my taxes for last year. And then my de facto mother-in-law, she's an accountant, and she didn't exactly do this thing, but it was pretty close. She was like, you've got all your taxes in the spreadsheet. I was like, yeah. And then she looked at it and she was like, what is that? And I was like, anyway. So I got to kind of file everything back out into TurboTax, but that was a fun thing to build.

Sacha: Yeah, I have something like that too. So for example, whenever I do my tax paperwork, I just have to have like, you know, the step by step checklist. Okay, this is where I need to go to get this number. This is where I can put it in. And then eventually it spits out a table that says, okay, put this in box 11, put this in box 13, so that I don't have to do the steps by hand. Because even before the, you know, for me, I use like simple stacks or whatever, it's web based. But before you get to the point where you can put the numbers in the form, you gotta go to this website, calculate this thing, and Org just makes all of that so much easier.

Shae: I agree. Yeah.

Sacha: And this remote lookup thing is something I'm always looking up because Org tables are so powerful, but also I need more examples in my life to remember how to use them.

Shae: Well, I think it took me four hours the first time to get it all figured out. But I can send you an example without showing it here. I can send you an example because I figured out, I think I've hammered the remote lookup down very thoroughly.

Sacha: And once you've got it right, you can just keep filling that in or copy and paste it. You have an example of the syntax and that's already all you need.

Shae: Right. I did run across some limitations of the evaluation method of Org mode spreadsheets. But maybe I've been using them a little too hard, if that makes any sense.

Sacha: Oh, what kind of limitation?

Shae: Honestly, I think I finally found a way to say every single... Because it was... So really the way that spreadsheets work is they're much more like Dataflow. And that is just that you end up with, like, either you work from the endpoint, which is like much more Haskell style evaluation, which is where you're like, I need to start here. What depends on this? But in the case where you have a whole bunch of different Org Mode spreadsheets, I think I ended up with this little text style hack where I just ran it a bunch of times. So it's like evaluate, evaluate, evaluate. Because remote lookups I ran, you know, I don't remember. And I think I took notes, but I don't remember. That's one of the great things about Org Mode is that I swear it's my, like, half of my brain is in my Org Mode notes. And whenever I had, I'm like, oh, what was that thing? I'm like, well, fortunately, with my terrible short-term memory, I took copious notes because otherwise I would never be able to get back to it.

40:55 finding notes with C-s

Sacha: What is your favorite way of finding those notes?

Shae: I actually use a lot of C-s just because I kind of have some idea of where they are in my tree structure and I'll also say I use a lot of my Org capture templates and they're not super complicated. I have like a to-do, I have a journal, I have ideas and like random ideas will float into my head like you saw Markov keyboard right it is like the weirdest art piece you've seen all day right and Markup keyboard shows up on the front page of Hacker News once a year or so. And people are like, programmers have gone too far. This cannot possibly be usable by humans or something. And I'm like, well, I don't know. I think it was art. And so a lot of times those things will drop into my head, something like that, where I'm trying to do something else. And so I will quickly write down the idea and then just gotten it out of my head enough that I can continue with what I was doing. And so I have a long list of strange ideas. A recent one was like, you've probably had your teeth worked on once or twice. And you know that the dentist always had to move the light around. And I'm like, but we have really good eye tracking. Wouldn't it make sense to figure out where the dentist or the car mechanic is what they're looking at? And then have the light move around behind them to figure out how to actually light up the place they're looking at, right? We've got vision tracking. Why don't we do this? But I don't really, yeah. I decided maybe I don't want to work on that one right now.

Sacha: It sounds like an involved project. Yeah. Yeah, yeah, yeah. Okay, so you're capturing, you're stuffing a lot of these ideas into an inbox.

42:35 Org Mode, managing inbox

Sacha: A lot of people are probably in the same boat where they've got these inboxes full of ideas. How do you deal?

Shae: I archive stuff when I'm done with it.

Sacha: Oh yeah?

Shae: Yeah, so a lot of times, and I find this very valuable, is like if I look at... Do I have it? Oops, that was not what I meant to do.

Sacha: Alright, so you basically just do aggressive speed commands, archive, archive, archive, or look at the agenda and just mark a whole bunch of things and say, that's it, that's gone. It was written down and then it can go.

Shae: Yeah, well, when I'm really done with something, when the thing is finished, then I will just archive it. I mean, do you use Archive much?

Sacha: I do. I have a function that goes through my inbox file and just archives anything that was marked as done.

Shae: Oh, nice!

Sacha: Because that way it clears it up, right? So I'll refile things where I'm like, okay, it's done, but it has important information. I want to put it somewhere else. But if it's just a transitory task that I'm using to remind myself, tomorrow I have to do this, go find the water bottle when it's done, I don't need to know about it in the future. So it's left in my inbox because I checked it off, and then periodically I'll say, clean up inbox. Not only will it remove all of the done things, but if I leave a tag In the title of the task or if the task matches certain regular expressions, it will refile it to the appropriate place in my kind of more permanent thing. So I can say, okay, all of my Emacs related tasks will get automatically refiled to my Emacs category without my having to do that manually.

Shae: So you're using tagging because I kept trying to do tagging and never quite did it.

Sacha: I use tagging sometimes when I remember it, but this is also why I use the The regular expression match against the title. I'm using Orgzly on Android to capture the thing on my phone. I might want to say this is a consulting task. File it in the right place so it doesn't get lost in my inbox.

Shae: Wow. When is your interview so I can learn from your tricks?

Sacha: This is now. Here we go! You can ask questions. The nice thing about conversations is that we jostle different ideas, and we are like, oh yeah, maybe I should write a blog post about that, because I take it for granted. So now apparently I have to write a blog post about my cleaning up process. My inbox is very long. The other thing, speaking of dealing with really long lists that I picked up from John Wiegley was I also sometimes remember to check this list of random items. So in my agenda, there's also like this, you know, random selection of things that I have not gotten around to thinking about further, but it's there just in case serendipity or boredom make me do something.

Shae: you know that's... I've thought about having... because you know, I've got the pop-up this little timer that pops up my agenda, but I've thought about maybe adding a section I don't know if I could add a section here but it would be something that says like at the bottom here's two or three random to-do's that have been open for a while just like for garbage collection. Because I know that in Jujutsu, I've got a cool little query that says, if you have any change sets that are more than two weeks old and are not in a permanent branch state, maybe you should do something about them. It's just called to do. It'd be kind of nice to have that for Org Mode as well.

Sacha: Yeah, it's just, you know, and our brains do these strange things with randomness, right? They're like, oh, I want to see what's new now.

Shae: Right, right, yeah. Oh, I have a question. You have this thing where you had...

46:28 Timestamps

Shae: I saw you taking notes with Prot, and you had this timestamp.

Sacha: Oh, yeah, yeah, yeah. I'm using it now. Okay, okay. So I have it bound two ways now. I have it as a dabbrev, so dynamic abbreviation, and I also have it as a yasnippet because sometimes I'm using it with either SPC or tab to complete it. And I don't really want to think, I just want to get the timestamp in and then move on. And so abbrevs can run functions to evaluate it. You can insert the timestamp that way. Or yesnippet, of course, can evaluate the thing. And now I have those. It's basically just a wall-clock time so that I can go back and plop in the chapters as time offsets, which are automatically calculated from the YouTube data on when the stream started. So I don't have to manually calculate my chapters. But it's super useful to have these times everywhere. And in this case, during a conversation, I want to be able to say, hey, we talked about something interesting. And then be able to go back to that point in the video later on.

Shae: So you're matching? Oh, oh, wow.

Sacha: So my shortcut for yasnippet is "ot" because I never type "ot" elsewhere, and it's close enough. I use Dvorak, so my O is on home row, and T is close by. Also, on the other hand... There you go.

Shae: Did I already show you that this is actually Dvorak?

Sacha: Oh, there you go. Now I can see the keycaps. Yeah, earlier it was kind of blurry, but now, yes, yes. So yes, that is my shortcut for inserting the timestamp. I previously added seconds as well, but then I realized that my kind might be false precision. So I just, you know, just use a minute at the moment and then I go back and adjust the timestamps a little bit later. But yeah, you can use abbreviations for all sorts of things, including times and dates and stuff.

Shae: Have you ever tried Org timestamp?

Sacha: Yeah, Org timer. So Org timer gives you a relative timestamp, right? You can say Org timer. Oh, okay. So, sorry. Are you talking about the C-u C-c ! or something of that sort? So that's actually what I initially was doing, but then it was too many keystroke word modifiers to remember. And then I had to press RET to select the, you know, thing. So now I just have an abbreviation insert the Org mode formatted timestamp for me. And then I have this code that searches for Org timestamp regular expression and then does the calculation and conversion and stuff.

49:12 Org timers

Sacha: So Org timer is a separate thing. It's useful for meetings and things like that. You would say, okay, your Org timer starts at the beginning of the meeting and then you can have a list and it automatically, like if you alt shift enter or something like that in the list, it'll automatically like insert the right timer, relative timer to it. There you go. So there's an org-timer-start. But the reason I didn't go that approach was because then you A. have to remember to actually start the timer and B. then you have to synchronize your time with video time. Which might not have started at the same time. So now I'm just like, okay, wall clock for everything. And then I can do the transformation with whatever I like. And since I'm editing my subtitles in Emacs, I can say, hey, this file started at this time, according to YouTube. And then just, you know, map all of the wall clocks to the appropriate subtitle times.

Shae: Wow. That's really cool.

Sacha: Anyway, so timers, relative, absolute, and using abbreviations is great. Which I think actually is a thing that I picked up from Karl. Karl Voit because he also likes to use... He has an abbreviation, not at the Emacs level, but he has an abbreviation on his system level, like with his window manager, so he can use this timestamp trick anywhere, including in Etherpad or wherever else where you want to insert the date and time. That's V-o-i-t, by the way. But yeah, so times are a great way to just leave yourself a pointer to that moment so you can go back to it later.

Shae: Now I'm curious, how well does that integrate with this sort of thing? Because I really like looking back at my history agenda.

Sacha: If you have it insert an inactive timestamp, I think it should still show up there. I think it will be a little like those.

Shae: Yeah, it looks like the... Well, it looks like these two are showing up.

Sacha: Yeah, yeah, yeah. Yeah, so that's a basic thing that I would have inserted by my either abbrev or... So it's not even dabbrev. It's just regular abbrev in Emacs.

Shae: What's the difference?

Sacha: dabbrev is like hippie... Okay, let me just double check here. I feel like dabbrev is sort of hippie expand-ish. It looks in your buffer or possibly other buffers. And I think hippie-expand and dabbrev, they kind of work together. It's an option to have them work together. Okay, so hippie-expand is... Oh, so I see. Hippie-expand is the more advanced version of dabbrev. dabbrev was Dynamic Expand, and Hippie Expand says, yes, that, but try a whole bunch of other things first. But my timestamp thing is actually just done by a regular abbrev, and I will find the thing in my config for "ot". Oh, yeah. I will put it in my chat.

Shae: My spelling, most people say my emails are spelled really well, but it's only because I have ispell set up.

Sacha: Yeah, ispell is great. I am learning French and therefore...

Shae: Oh, c'est très bien. Je parle un peu de français aussi.

Sacha: Oh, oui. I'm keeping a journal in French on my blog and I have the Tatoeba Project with all the example sentences and I have a consult interface to look up stuff in them so I can just borrow other people's words and try to make it sound more natural. Plus of course the usual searching for words in dictionaries and stuff. Anyway, in the chat, I put in my global abbrev table definition for insert format time string. In case you want to steal that, it's right there.

Shae: I will definitely save that into my notes here.

53:53 Org Mode snippets

Shae: Another thing I use a lot is I use Org Mode snippets. I will tell you that the first time, I guess if I look back at... This is another thing that I have done a lot of in the past, which is where... I love the fact that Org Mode snippets are just executable. I can just run them. I guess two jobs, three jobs ago, there was a case where, because I would keep the results around and look at them, there was a case where, I guess a couple of months before, something got shipped to a customer, and I noticed our database schema had changed and I prevented a tremendous amount of upset and emergency by being like this doesn't look great. I got one from two weeks ago, and it does not match. Something's wrong here. Everybody's like, I don't think so, Shae. And I'm, like, no no no, we do have a problem, we've got to fix this. And they were, like, oh crap! And then I was like, yeah, solved a problem!

Sacha: Yeah, I basically try to do as much in a snippet instead of in, you know, in a scratch buffer or whatever, just because having that record, the fact that I did it, and also any notes that I had leading up to it and the output of it, it's just so helpful.

Shae: Oh, I've got a cool thing that I'm doing for work. And that is that our readme file is not only a word file, but we also have the demonstration of our actual thing is done by using like dependent snippets. And so that means that like if you want that, perhaps this is something everyone already knows, I don't know, but we basically are using the results of earlier commands in later places. And the other nice thing about that is that then when we want to check, we have to effectively dock tests, right? When we want to check and see if our software works the way it does in the readme, we evaluate the final Org Mode snippet, which then calls it forward, calls it forward, and then if something goes up or not. Well, I guess I need to fix something. And so it was pretty exciting to put Org Mode niftyness into our, into my Word reading file, you know?

Sacha: Nice, nice. And you did mention your other coworker is on board with the whole Emacs thing. So that's one of the things that people are often like, I want to use Org Mode and I want to use it for like the documentation or the testing or whatever, but they got to get everyone else on board with the thing. Otherwise it's Jupyter Notebooks or whatever else, right?

Shae: Right. Okay, so I have a joke for you that I came up with a long time ago, and that is, do you know the only way, there's only one way that Sauron could have organized the invasion of Middle-earth, and do you know what he used?

Sacha: What?

Shae: Orc Mode. It's a terrible joke, isn't it?

Sacha: That's okay. I'm sure someone in the comments will come up with an even worse pun.

Shae: I'm excited! It's going to be great!

Sacha: Never underestimate the punniness of the Emacs community.

Shae: I completely agree. I don't know. Do I have anything else exciting in here?

57:15 Compilation finish function: handle success

Shae: I actually really like this one. I used to run all of my tests in compile. F12, I have F12 bound to compile. And one of the things I wanted was, I wanted something where it was, if the compile is successful, don't show me the results, because everything's good. And so since I'm doing stuff in Rust, when I run all the tests, it leaves the buffer up, and I need to get around to actually doing stuff like this for Rustic mode as well, where when the tests pass, just go away, because it's all good. And when the tests don't pass, show me where to... I need to look at the problem. And I got this from Enberg and Emacs, I don't know, 20 years ago. Maybe it was less than 20 years ago, but it probably wasn't. So yeah, there's so much good stuff. Yeah, there's just so much good stuff. And I also like to, oh, look, here we go. You can see that this is long gone, by the way. It's not there anymore.

Sacha: I have a proper, you know, it's sachachua.com/dotemacs. A lot easier to remember. But yeah, and I think that's, yeah, yeah, I remember that now. defadvice is also obsolete. The new hotness is advice-add or something like that.

Shae: Oh, really? I'm going to make another TODO item for there.

Sacha: I was digging through my notes trying to find, do you share your config anywhere?

Shae: No, but you know, at this point if I share it on YouTube, I might as well just throw it up somewhere. Why not? It's not very exciting. Like if you look at someone like Ross Baker who has magic, like wow, is there some magic coming in from Ross Baker? I'm so excited to see more stuff from him. There's just like, I guess I feel like compared to almost everybody else I know, I feel like a power user. Because I'm like, you know, I wish I could do this thing. A lot of times someone I know is like, well, I did that thing and here's a library. And I'm like, yeah, I'll have to do it. And I just, I guess I feel like I'm a power user. And on the good side, I guess I kind of, I really haven't written that much Elisp ever, like I was saying in the comments during your interview with Prot. And I kind of like to, it's just I guess it's never quite gotten to the top of my stack. And I did decide it was time for me to send money to Parade for at least for themes, if not for like, please teach me some Elisp so I can actually, because you know, it's not that Elisp is hard. It's more like, how do I kind of, what are the things I interact with? What are the words? What's the vocabulary of working with Emacs? I don't actually really know. As a user, sure, I can do cool stuff. I can do Lisp macros. I've done Scheme and Lisp some of the past, but not inside Emacs.

Sacha: Alright, so let me clarify. After more than 20 years of using Emacs, did you say you feel like a power user or do not feel like a power user?

Shae: I definitely feel like a power user, but I don't feel like someone who does much of anything with Elisp. I don't really feel like someone who has much of a clue in the internals. And that's not entirely true. I have some of the ideas. But for the most part, I haven't actually needed to know that much about the internals. And sure, I've dug into things like how do you efficiently work with large buffers in your ??, like the ropes data structure and stuff like that. That was more for fun. Although it is something that Emacs does and does extremely well. But I'd kind of like to... There's a lot of things I'd kind of like to change and I don't really have enough of the understanding of the kind of how I would write the Elisp to do it. Here's a good example. When I hit F3, it takes me to the one I'm currently clocked into. Unless I haven't clocked in to something since I started Emacs. And honestly, I would like to use something like org-ql, the Org query language, to go find if I've just started Emacs, and Org does not know about something, you know, I just want you to go search for it. I have so many cores and so much memory, just go find it.

Sacha: That sounds like an excellent reason to go learn Emacs so that you can have it... If you're not currently clocked in, go find the most recent clocked in task and go there, or maybe present you with a list of things and then go from there. I would love to hear about your Emacs Lisp learning journey because that's one of the big things that moves people from, you know, power users, yes, but users, to using Emacs as a lightweight editor toolkit for something that's custom fit to exactly what their workflow is. And on that note, I'm going to try to wrap up gracefully before the kiddo, you know, just like drags me out here. Thank you so much for doing this. I look forward to more conversations. I'm going to post the transcript and other things like that pretty quickly, I think, because I have this nice workflow now that lets me take screenshots and everything, but there's so much here that I want to unpack. But I hear the kiddo, bye!

#+begin_export 11ty

<a name="end-ec22-transcript"></a></details> #+end_exportbvt

Chat

• JacksonScholberg: ​​Emacs is fun
• JacksonScholberg: ​Apple's touchpad is another option
• JacksonScholberg: ​Trackpad
• JacksonScholberg: ​Lol
• JacksonScholberg: ​I was curious about what you are tracking your time working on
• JacksonScholberg: ​How you track it.
• JacksonScholberg: ​You clock in and out to what you are working on. I like that idea.
• Bezaar.musicc: ​​That's great!
• PuercoPop: ​​the buffer api (properties) is the hardest part for me
• charliemcmackin4859: ​​I think you still have a timer going, btw

Find more Emacs Chats or join the fun: https://sachachua.com/emacs-chat

View Org source for this post

You can e-mail me at sacha@sachachua.com.

Jonathan Chu is a software engineer and Emacs enthusiast who’s been looking for a note taking app that he can actually use. He’s tried all the usual suspects but found them too opinionated for his liking. He wanted to work in Emacs and write his notes in Org mode but none of the existing packages were quite right. So he did what Emacs users always do when things don’t work exactly as they like: he wrote an Emacs package do things the way he wanted. The result was grove.

Chu says that Grove was informed by his experience with Obsidian. I’ve never used Obsidian so I can’t comment on that aspect but Chu says that Grove is Obsidian-like. The only external dependencies are ripgrep, Graphviz if you want the graph view, and Consult if you want the enhanced search capability. One of his goals was to have an easily installable and configurable package.

It looks like a pretty nice package if you’re looking for a note taking method with a bit of but not too much structure. I use Org mode for all my note taking across many dimensions and have never felt the need for a more organized approach. Sure, sometimes I think about using Denote or Org Roam but—for me—they never seemed worth the effort. Many others disagree, of course, but Emacs has a home for us all,

Take a look at his post or the Github repository for the details and a bit more on how things work.

I've released an update to blogmore.el, my Emacs package that helps me out when writing this blog. I've added two commands to this version which help me be lazier than ever.

The first is blogmore-become-like. When run, this prompts for another post and, once selected, it sets this post's category and tags to be the same as the other one. I added this because I'm often writing an occasional series of posts that are all about the same project, and so I always find myself copying and pasting those frontmatter properties from another post.

The second command I've added is blogmore-toggle-image-centre. Built into BlogMore is a little bit of styling that will ensure an image is placed in the centre of the page, if the URL for the image has #centre on the end. This means that, for most images I add, I have to go and edit the URL to add that. Now I can just run a single command when the cursor is on an image and it'll add (or remove, if it's already there) that styling hint.

In both cases, I've added the commands to the transient menu too.

capture icon

Product: Capture
Price: $7.99 · lifetime updates · up to 5 Macs · 7-day free trial

Capture is a product designed to capture something, and move on with your life. It is an universal product, you can be in any application, Safari, Chrome, BBEdit, Finder, anywhere. You can press the keyboard shortcut to invoke capture. Fill in what you want to capture. Hit return and go back to whatever you were doing.

The product is advertised as “Capture thoughts to Obsidian without leaving what you’re doing.” You don’t have to use Obsidian. I use Emacs and it works great for that too. You can use any text editor and it is as useful.

Two Routes

capture options

Capture gives you two options to capture your content.

1. You can capture to a new individual file. Every capture gets put into a time-stamped new file.

capture where?

1. You can append to an existing file which you have specified, or append to a daily note.

capture and folders

You can define the Obsidian vault that Capture deals with. In my case it is the folder which contain my org files. Within that folder is another folder called ‘capture’ where I put my captured files into.

capture context

Within these options you have various options. You can include context. You get to define the context.

capture tags

You can add tags to your captured content.

I am happy with Capture. It is a focused utility which does what it promises well.

Wishes for Capture

1. I understand that the link to Obsidian means that this deals with Markdown files. We don’t need that restriction. It can work with Org-mode files and plain text files. Give me the ability to specify the extension I want my files to be.
2. The command to save the capture is ⌘↵. On my machine ↵ saves the capture. There is no way to add a new line. This must be a bug.

Recommendation

I used the program for fifteen minutes and bought it. It is the kind of utility which I am going to use multiple times a day.

Recommended most heartily.

macosxguru at the gmail thingie.

twtxt was one of the strongest inspirations behind Org Social: a plain text file served over HTTP, with no active server, no database, no signup. I personally admire the work done by Buckket: the concept is so powerful that it has captured the hearts of many people over the years. Its author gave us an elegant solution for creating a personal microblog, an alternative to Twitter (now X).

That said, Org Social would not exist if it weren't for the limitations of twtxt or the natural evolution of social networks. Org Social keeps its spirit, learns from its mistakes and from the competition, reinforces other concepts (like federation) and adopts modern features (like visibility). It is not an improvement, it is a shift in approach.

That's why I'd like to go over the three most important aspects where Org Social improves on twtxt.

Technical improvement

The most obvious one is the ability to have structured metadata thanks to Org Mode.

#+TITLE: Bob's journal
#+NICK: Bob
#+DESCRIPTION: I'm a software developer and I love open source.
#+AVATAR: https://my-awesome-website.com/avatar.jpg
#+LINK: https://my-awesome-website.com
#+FOLLOW: https://foo.org/social.org
#+FOLLOW: https://jane.com/social.org

* Posts
** 2024-12-12T12:00:00+0100
:PROPERTIES:
:LANG: en
:TAGS: emacs org-social
:CLIENT: org-social.el
:VISIBILITY: public
:MOOD: 😊
:END:

Hello Org Social!

This opens the door to giving context to each post, having native threads, tagging, organizing in groups, defining visibility, running polls...

We don't just get richer post bodies: the possibilities for interaction between users grow without limit. The specification invites you to create, not to work around limitations.

5 design principles

Org Social follows these principles:

• Simplicity: the format must be easy to understand and write with any text editor, with no special tools or advanced technical skills required.
• Accessibility: the feed must be readable by both humans and machines.
• Decentralization: every user should be a node, a self-hosted feed or one publicly accessible.
• Org philosophy: the format must take advantage of Org Mode features, like links, tables, code blocks, checkbox lists, etc.
• Your information belongs to you: no one owns your feed, content, or followers. Just you and your text file. Where you host it is a separate matter.

Without clear rules, the ecosystem fragments. There isn't a single line of the specification that isn't aligned with the points above.

Infrastructure should add value, not be a requirement

A very important element in Org Social are the Relays, which let you organize threads, discover other users, receive notifications, run searches, get an RSS feed, etc. However, without them the network would still work: users could keep publishing, following others and interacting. Relays are not the core of the social network. Clients can rely on them, but should never depend on them. This isn't a quality exclusive to Org Social: twtxt is also aligned with this principle. The point lies elsewhere.

The goal of clients is to make reading and writing feeds (social.org) easier, not to be a requirement to participate. That said, they are very practical for building your timeline, since you need to read and sort the feeds of the users you follow. For that there are Desktop and Android versions thanks to Emacs, plus a native iOS version written in Swift.

The differentiating point is balancing different user profiles via the infrastructure. For example:

• Users with no technical knowledge: in a couple of clicks you can have an account thanks to Org Social's free hosting. The clients will take care of syncing and publishing for you. It is very similar to how other networks like Mastodon work, except that everything lives in a plain text file locally and transparently.
• Users with some technical knowledge: they can host their social.org on GitHub, GitLab, their own server, etc. They control and manage where it is hosted and how it connects.
• Users with deep technical knowledge: they fully control their presence on the network. They run their own server (with WebDAV, for example), with their own configured domain, with their own caching policies... or they even spin up their own Relay for extra speed or to build private federations.

It embraces every kind of user, without sacrificing the essence of the social network. You don't need to be an expert to take part, but if you are one, you control every byte.

Conclusion

Org Social doesn't just improve on twtxt technically: it also evolves the concept of a social network on top of plain text. It takes a step forward by providing more infrastructure and incorporating modern features.

The future is not about going massive or competing with Mastodon, but about satisfying a very small niche of users.

Focus on the content or on engaging with others, Org Social will take care of the rest.

Yesterday I joined Sacha Chua for a new episode of her Emacs Chat podcast, where we talked about Emacs and life. I gave a quick tour of my Emacs configuration, discussing at length my configurations for EXWM (Emacs X Window Manager) among other topics like Emacs's facility for visually indicating buffer boundaries in the fringe by setting indicate-buffer-boundaries and my convenience configuration macros.

The above video is provided with closed captions and the below transcript courtesy of Sacha with minor fixes and formatting by me. I've included some of Sacha's screenshots from our chat, you can see the rest on the episode's page on Sacha's blog.

A few links from our chat:

• my literate GNU Emacs configuration
  • .emacs.d - configs - My configuration for GNU Emacs and other programs
• personal fork of QMK firmware with my keymaps
  • my custom keymap for ZSA Voyager split ergonomic keyboard
• my upcoming ffs (Form Feed Slides) package for simple presentations

It was a lot of fun - thanks again for having me, Sacha!

Take care, and so long for now.

I understand the gravitational pull of Emacs though for me it's been Vim/Neovim. I've spent entire year trying out tools like VSCode and Atom and sure they had some features that were neat, but they were never Neovim.

It's been at least 5 years since I tried another editor for coding though after realizing that I'd just go back to Neovim, which brings me to my Emacs adventures. I tried nvim-orgmode and it sort of worked but had issues that I was never able to work through. Then I went back to Todoist for a bit and missed orgmode, even if it was a hobbled form in Neovim.

This led me to Emacs and orgmode which I've been loving for about a year now. Still I keep wondering if I should move my coding workflow to Emacs and abandon Neovim?

There is a pull to just use one tool.

This month's carnival topic is "may I recommend...". I'm too new to Emacs to recommend some fancy package or an interesting workflow so I'll reach back to my 20+ years doing software and finding tools.

May I recommend....keep it simple. Don't grab 50 new things from some video or blog post that some creator put up. People do that because it looks cool and then they over complicate their systems and abandon them. They layer complexity that looks cool over a system that already is working for them to solve problems they don't have with solutions often produced by people whose job is to get a new piece of content out that will go viral and pay their bills.

Many times it doesn't even seem like the creator uses the system at all, it just looked cool and had the proper keywords for what's popular right now.

I say, identify a problem you actually have. Spend some time researching options. Try out a few of them to see what works. Then stop messing around with your system and get work done.

• I always hear about the carnival from Sacha

Protesilaos (Prot) has an excellent post on keyboard ergonomics for Emacs users. He considers various strategies for making Emacs commands easier to use and less likely to cause RSI damage. He considers everything from split keyboards to evil-mode.

He says he has both a split keyboard and a keyboard with a normal form factor. He says that the split keyboard is not a magic solution and that what works best for him is to configure “one shot modifiers” where the modifier is simply pressed—but not held down—before the key it modifies. So, to use his example, Ctrl+x is typed by tapping the Ctrl key and then the x key.

Along with that he suggests ordering the modifier keys in a way you find comfortable. The most important thing, he says, is to keep the Ctrl key close to the space bar so that you can use your thumb to press it. It’s also important to have the modifier keys located symmetrically so that, for example, you can use either hand for the Ctrl key.

As for the common advice to map Caps Lock to Ctrl, Prot says that’s okay but that it encourages the bad habit of always using your left pinky for Ctrl.

There’s a lot more information in Prot’s post—including how to configure one shot modifiers—so be sure to take a look at it.

I’ve been incredibly lucky. I use a standard keyboard, map Caps Lock to Ctrl and don’t have any symmetric modifier keys. Nonetheless, I haven’t suffered any RSI problems despite spending the majority of my day at the keyboard. But, as I say, I’m lucky. The smart thing to do is to read and head Prot’s advice.

I almost always reach for project-vc-dir when I want a VC status overview, and most of the time this is exactly what I want, the whole project laid out in one buffer, every modified, added and unregistered file in the repo sitting right there, ready to be diffed or committed. But every so often, particularly when I am deep inside a big repository and I only really care about a single subdirectory's worth of changes, that project-wide view is, frankly, a bit too much. Too many rows, too much scrolling, too much noise.

So, what am I actually after?, I want the same vc-dir buffer, but scoped to whatever directory I happen to be looking at, most commonly the directory I have open in dired. And it turns out this is almost trivially easy in vanilla Emacs.

The bit I had not initially appreciated is that vc-dir itself already accepts a directory argument, it is the interactive prompt that steers you towards the repo root, because it defaults to (vc-root-dir) rather than default-directory. If you call it non-interactively with a subdirectory instead, the Git backend quite happily scopes the status listing to files underneath that path, even though the overall VC root is still the same project root.

So the fix is a tiny wrapper that just hands vc-dir the current default-directory and skips the prompt entirely:

(defun my/vc-dir-here ()
  "Run vc-dir on the current directory (dired's dir when called from dired)."
  (interactive)
  (vc-dir default-directory))

Then, because the main place I actually want this is from within dired, a keybinding that sits nicely alongside the standard C-x v family:

(with-eval-after-load 'dired
  (define-key dired-mode-map (kbd "C-x v D") #'my/vc-dir-here))

The mnemonic, such as it is, is that C-x v d is the normal vc-dir binding with its usual prompt, and capital D is the "here, right now, this directory" variant. Lowercase for the prompted version, uppercase for the zoomed-in one, which also pairs up nicely in my head with project-vc-dir being the zoomed-out project-wide thing on C-x p v.

So the little two-tier workflow I have settled into is:

• C-x p v – project-vc-dir, show me everything in the project
• C-x v D from dired – my/vc-dir-here, show me just this subdirectory

And that is really the whole post, nothing clever, no new package, just a three-line wrapper and one keybinding, but it has genuinely taken a surprising amount of friction out of navigating VC state in large repos where I know perfectly well the only thing I have touched is under src/foo/, and I do not particularly want to be reminded of every other outstanding change elsewhere in the tree.

And yes, magit can do this with some narrowing, but actually, I like vc-mode!

I've moved the repositories of the geiser packages I maintain to codeberg, so make sure you update your remotes if you access them directly through git. The URLs are already updated in the ELPAs, so nothing changed if you installed them via their packages.

Seventeen years and running. Happy hacking!

I chatted with Amin Bandali about Emacs, configuration, EXWM, keybindings, audio, and life.

View it via the Internet Archive, watch/comment on YouTube, read the transcript online, download the transcript, or e-mail me your thoughts!

Links:

• Emacs Chat with Sacha Chua - bandali - Amin's blog post about this talk
• Amin Bandali: a computing scientist, archivist, and activist for user freedom
• bandali's GNU Emacs configuration
• .emacs.d - configs - My configuration for GNU Emacs and other programs
• The People of Emacs - bandali
• emacs-exwm/exwm: Emacs X Window Manager · GitHub

Transcript

Skip to end

Transcript

0:00 Introduction: Amin Bandali, software developer and free software activist

Sacha: Let me do the thing. Go live. Let's check in. Alright, hello. This is Emacs Chat 21 coming back after a decade of not doing it, so… And today I've got Amin Bandali who's a… Is it seven years now that we've been doing EmacsConf together?

Amin: I think so. Since fall 2019. Yeah.

Sacha: Yeah, yeah, yeah, yeah. But of course you also do a whole lot of other things. I was looking through your Emacs configuration and there's like translation and other stuff in there. So would you like to start off with a brief introduction of who you are and how and why you use Emacs?

Amin: Yeah, sure. Yeah, first of all, hello, everyone. Sorry if I'm looking to the side. This is a new setup. My laptop, which has my webcam, is there, but my main display is here. So I might be looking to the side from time to time. But yeah, that aside, hello.

1:05 Aspects of life: notetaking, editing, multiple

Amin: Yeah, I'm Amin Bandali. I've been, I think, using Emacs since 2014 or 15, so I guess more than a decade now. I'm a software engineer by day, or software developer, slash programmer, slash computing scientist. I'm also a free software activist. I volunteer on a lot of free software projects as well, which Sacha mentioned. I do things around GNU. I volunteer with FSF. I'm a Debian Developer, so I try to maintain some packages in Debian. I try to help run EmacsConf from time to time. Hopefully this year I will be much more present. But yeah, that's that. So I first got into using Emacs, I guess, as a programmer tool, like as a text editor. But I've since then kind of integrated it into a lot of other aspects of my life. And I do much more with it, as I'm sure a lot of us do. Yeah, so I use it for kind of note-taking, just any writing, editing purposes in multiple natural and programming languages. Reading and sending email for chatting via IRC. All of that good stuff.

Sacha: This is the sort of thing that isn't immediately obvious from your configuration. I know you've got your Gnus setup in there and you've got your ERC setup in there, but sometimes when newcomers are trying to figure out, okay, there are all these packages, but how do I use them to get stuff done? That's one of the reasons why we want to do this Emacs chat, so that maybe you can show us some of the cool stuff. We are live, but if you accidentally show something personal, let me know and I can kill the stream within 10 seconds and I think then we can be like, okay, we'll just flush that out and then come back once we've hidden the top secret plans for taking over the world, that sort of thing. Sounds good. Where do we want to start?

3:00 Configuration: keeping things simple

Amin: I'm happy to do it however you like. I can either share my screen, pull up my configuration. Yeah, okay, so let's do that.

Sacha: Yeah. If you share your screen sometimes, I think what we did ages ago was we just started walking through the configuration and then sometimes people say, oh yeah, that's really interesting. Let's go and demonstrate that so that people can get a sense of how this actually works. And there were some things in your configuration that I had no idea, like what is FFS? There's like no package. I couldn't find any information about it. But yeah, so your config, if you want to go ahead and share your screen while I Fill the air with hand-waving. Amin's config tends to be more on the minimalist side. I think you mostly rely on built-in things with a couple of external packages. You don't even use use-package at all. It's all run-at-idle-time to delay the startup of various things, and then it's all vanilla Emacs as you can get for loading and configuring things.

Amin: Yeah, pretty much, yeah. Yeah, so before I continue, quick note, Sacha, if you can make me presenter because I don't have access to share my screen.

Sacha: Oh, that would be important, yes. Hang on a second. Let me see. Okay, here we go. Make presenter. I might as well promote you to moderator while we're at it. There you go. You should now have magic powers.

Amin: Thanks. Let's see.

Sacha: It's a good thing we're practicing this before EmacsConf so I remember how all this stuff works.

Amin: Yep, for sure. Okay, let's see. I think I got it now. Can you see my screen?

Sacha: Yes, I can see your screen.

Amin: Okay, excellent. Let's see. Okay.

4:58 user-lisp-directory, site-lisp if you're using an older Emacs

Amin: Yeah, so as Sacha mentioned at the moment, my config is kind of very minimalist and kind of conservative by design, in part because I tend to work on a lot of different machines, whether it's for work or volunteering or whatever, and I prefer to use Emacs if I can. So I want my config to be fairly self-contained so I can easily either git clone or rsync it over. Yeah. To keep it simple, I was using package.el for a while for installing and managing my packages, which I don't keep in my configs repository. But then I decided to switch over to very manual package management with the awesome new feature user-lisp-directory of the next upcoming Emacs release, which basically you can give it a subdirectory in your ~/.emacs.d or ~/.config/emacs. And then it'll go through all the Emacs Lisp files recursively, byte compile them, native compile them, all that good stuff, and add them to the load-path. And for people who are using existing or older releases of Emacs, there's also site-lisp by Philip Kaludercic, which is kind of the… I guess first implementation of what later became User Lisp and built into Emacs. So you can make it conditional and fall back to site-lisp if you want to be able to use User Lisp on older Emacs but still have your configuration be usable. Yeah, anyway.

6:32 Organizing configuration into modules

Amin: So I've experimented with like a couple different ways of managing my configurations like single giant init file of like four or five thousand lines which I know is actually not very large by comparison to I think like someone like Sacha's configuration and also like You know, split into multiple different files, which has its own benefits. And I've kind of actually converged to the approach that Prot uses. If you actually take a look at my configuration file, you see I've drawn a lot of inspiration from Prot switches. Having a literate single file configuration, which then all of the Emacs Lisp source blocks get tangled to individual files. So I can maintain a single source of truth and edit it all in one place, but then also easily be able to share individual pieces to people if they want. So yeah, that's kind of the general approach. And I can dive right in.

Sacha: Yeah, that's definitely the structure that I've also stolen from Prot. And I like the way that you're Your heading names are all long and descriptive, and you've got everything broken down in detail. So yeah, go ahead and walk us through it, please.

Amin: Yeah, sure. Let's see.

7:45 early-init

Amin: So that's a brief introduction, and then I have an early init section for doing the early init file. There's a couple of subheadings here. Actually, let me enlarge the font size a little bit to make it more legible. OK, great. I do a couple of things here like disabling package at startup because I don't use package as I mentioned. I manually install and update my packages as git submodules in my configurations repository.

Amin: I set load-prefer-newer to t to make sure that I never load any stale code. For example, I might edit some Emacs Lisp file by hand and forget to byte compile or native compile it. And this tells Emacs to basically just use the version of these three variants that's the most recent. Yeah. Nothing super fancy here.

Amin: I turn off a couple of things that I find a little bit distracting, like the menu bar or toolbar. Although I do say here that for people who are new to Emacs, they're actually super helpful. Sure, it's a little bit of visual clutter, but in the beginning, it's really, really helpful to help you orient yourself of what mode you're in, what tools do you have available in your disposal. And even someone who's been using Emacs for more than 10 years, I also use it sometimes when I'm like… just starting to use a new mode. So yeah, good stuff.

9:06 ring-bell-function

Sacha: I was very amused by the comment on the… "I don't like getting jumpscared out of my chair." You turned off the bell.

Amin: Yeah, because that actually used to happen when I first started using Emacs. Like when I would, I don't know, I don't even remember when it bells or rings, but Maybe if you like quit like with C-g or like try to backspace into like delete where there's no more characters to delete so it rings a bell and it's very like can be jarring so yeah I turn that off.

9:40 performance optimizations

Sacha: Yeah, and then you've got a whole bunch of things where you set some variables to nil temporarily to make it faster, so that's in your startup in garbage collection.

Amin: Exactly. Empirically, there is no hard and fast science behind this. I experimented over the years. I'm pretty sure I believe the default, for example, the garbage collection cons threshold is about eight megabytes. I tried increasing that a little bit to see how much If I increase it to what point will it make my startup faster? And I found this 30 megabytes or mibibytes to be kind of a sweet spot. So I bump that up. And then after Emacs has finished initializing, in the after-init-hook, I just restore the defaults.

10:25 user-lisp

Amin: And then, yeah, this is the bit with the user-lisp-directory that I was talking about. Awesome stuff. So you can basically designate a directory. For example, in my configuration, it's just a lisp directory. And then on startup, Emacs will go through and byte-compile, native-compile if necessary, and then add all of that stuff to the load-path automatically. So you get that. Yeah, and then this is the bit about site-lisp that I was talking about. So if you want to use user-lisp, but you're still using older Emacs versions that you maintain, you need to maintain backward compatibility in your config. This is how you do it, for example. So you just yeah, add it to load-path, require it and then call prepare-user-lisp. That's about it.

11:14 ignoring byte compilation warnings

Sacha: I'm picking up that tip about using the ignore directories. I'm getting by with just ignoring all of the byte compilation output, but it would be nice to just say, you know, that stuff is test. I don't need to worry about it.

Amin: Right, right. Thanks. Yeah, I was also doing that. I actually have it as a comment to suppress warning types, like byte compilation, but I was… I plan on working on some packages, whether my own or others, and it would still be helpful to get those warnings, so I keep them enabled. It's still a bit annoying. I still get some of them when I launch emacs but I don't restart or launch emacs as frequently so it's pretty bearable.

11:55 init-file-debug = --debug-init

Amin: Yeah, and then I have the main init file. And there's not much in it. It's just the debug-on-error and debug-on-quit. So the debug-on-error thing, I set it to the value of init-file-debug. And if you look at that, the help for this variable, basically if you pass or launch Emacs with --debug-init, this variable will be true. So yeah.

Sacha: I did not know that. Cool.

Amin: Yeah, it's pretty helpful. I think, if I'm not mistaken, I took this from John Wiegley's dotemacs, but I can't remember for sure. It's been years. Yeah, it's pretty nice. And then here, I just set my name and email address. And very early I set a custom-file to keep all of that stuff separate from my .emacs. I don't want it mixing in.

12:53 Core

Amin: And then pretty much the only other thing that's in my main init file is just to require and load these different modules or packages of my configuration. I have these as actual packages or as actual features. They provide themselves. And that's just something that I've found straightforward enough to do. I know, for example, Prot uses a dual approach. He has some of his configuration that's more readily usable, available as actual packages. And then the other ones, it's just Emacs Lisp code. It's not actual packages. But for me, I just keep it simple. Everything as packages and that's about that.

Sacha: Fantastic. Let's dive into some of those configuration modules.

Amin: Sure, let's see. Yeah, so this there's this like core thing which is kind of included gets included in all of my other files.

13:53 no longer using bandali-configure; scoping errors, timing execution

Amin: I wrote a bandali-configure macro shamelessly based on prot-emacs-configure which is what Prot uses and it basically is a way of kind of similar to use-package for like wrapping a bunch of relevant like Emacs Lisp code all together. It has the benefit, if you use it, if there is an error in that block or in the body basically, then it won't crash everything. That body will just get ignored and we display an error. And that's also the main reason that Prot uses it. The one thing that I added extra to mine, which I took with inspiration from Eshel Yaron's esy/init-step, is to wrap it up in basically time the execution of each of these blocks, which can be pretty helpful to help you see, okay, which part of my configuration is particularly slow. Usage examples. I just have it here. You can either basically pass it like a symbol like thing or you can also pass in a string as the first argument. And this is what will be displayed when you display a list of the evaluation times for all of these blocks in your configuration.

Amin: Yeah, and then I have a neat little function here like bandali-configure-report-times that will report these times, whether in the order that it's encountered them, or you can have it sort by fastest to slowest, slowest to fastest, blah blah blah.

Sacha: You mentioned you're no longer using this. Is it because you wanted it to be easier to copy and paste your code? What got you to shift back to the regular vanilla type of configuration?

Amin: Right, as neat as it is, I didn't find it super useful. For one thing, because I don't add or remove a ton of stuff to my Emacs configuration regularly, so if there is an error, it wouldn't cause an issue for the rest of my configuration. I didn't really find that very useful. And then my other potential concern is that the way I was structuring things, I would put all of the configuration, let's say for Gnus, in one of these blocks. But I wanted to be able to break that down into, for example, Org Mode sections more easily. So far, I just decided to not use it. I know I could technically break those down into smaller blocks, but I haven't done that yet.

Sacha: Ihor says, this configure macro looks a lot like good old use-package, which you're not even using in the rest of your config. And I hear you about wanting to be able to split things into smaller blocks with more explanations in between them. So in my config, yeah, sure, I've got the use-package there to do the ensure and all that stuff. But I also have with-eval-after-load because I still want, you know, the links and the screenshots in between.

17:02 Why not use use-package

Amin: Right. Yeah, exactly. use-package is awesome. I have used that in the past, especially when I was using the straight.el package manager. It pairs nicely with it. But yeah, since then, I found it a little bit like too magical for my tastes, kind of along the lines of declaring an init file bankruptcy at some point I really wanted to understand every single line that I have in my Emacs configuration. And at the time, I didn't know a whole lot about macros or wasn't very well-versed with them. So I just ditched it in favor of simply using, as you mentioned, with-eval-after-load. And then that causes all that code to be basically delayed, not evaluated immediately, but when that package is loaded. And then as to when to pull that package in, depending on if I want it right from the get-go of my Emacs start, then I would require it. Otherwise, I add this, as you also mentioned earlier, this kind of timer thing where if Emacs is idle for, I don't know, 0.2 seconds or 0.4 seconds, then go ahead and require this package.

Sacha: Ihor has a tip in the chat. Of course, Ihor has an Org way to do this. He uses use-package whatever config and then he has a noweb reference to the Babel blocks. Then he just says :tangle no on the source blocks so that they don't actually get repeated. Anyway, you can look at it later when you go through. I'll send you the comments or whatever. But show us how you're actually configuring things since you're not using this.

18:37 Defining multiple keybindings

Amin: Then I just have another quick macro thingy here, bandali-define-keys, which wraps around Emacs's define-key. It affords me the convenience of defining multiple key bindings, and Prot's version of this (I think it's prot-emacs-keybind, or something like that) he imposes the limitation that the keys should be valid strings that can be passed to the kbd function, which is very fair and valid, but I wanted to not impose that, to keep the flexibility of using define-key directly. The consequences of that, as we can see, is we can pass in the old representation of key bindings, like the vector or whatever syntax, which Prot's doesn't support by choice, whereas mine does. Let's see. For example, let's look at the bandali-theme.el, which is all about… The appearance, I guess, of Emacs.

19:45 doric-oak uses emphasis instead of colours

Amin: Yeah, so I just have a conditional block where, you know, if you're in a graphical environment, I'll just go ahead and load Prot's doric-themes, specifically doric-oak, which is what we're seeing right now. I'm using, it's very beautiful, it's very subtle, and it uses emphasis, bolding and stuff to draw your eye to something instead of using a million different colours, which I find pretty nice. Yeah, and then for example here I set up some fonts. I use this Sahel font for Persian and Arabic text. I set a colour emoji font here and this is like we get a kind of preview of what I do. It's like with-eval-after-load 'faces and then blah blah blah.

Sacha: Ihor would like to point out that with-eval-after-load is also a macro that calls another macro. So I'm just going to mention it because it's there. These are your fonts. This is your theme. This is great because everyone always asks, what theme is this? What font is this? All right.

20:49 global font scaling instead of the local ones

Sacha: I like your text scaling tweaks that you're just about to go into. You've changed the global mappings.

Amin: Yeah, yeah, yeah. And I actually took this from Prot as well. And it makes a lot more sense. So by default, this, C-x C-+, -, blah, blah, blah, it only scales the text for the current buffer only. But in newer versions of Emacs, in Emacs 29, they also added commands to adjust this globally, including the mode line and all that stuff, which is usually what I want, for example, in this presentation or when I'm sharing my screen right now. It scales everything up globally. So yeah, I just swapped these to be the default, and then I add keybinds for the just local variants in case I need to use that. Yep.

21:37 display-fill-column-indicator

Amin: And then here I have display-fill-column-indicator. I don't know, maybe this is just me, but sometimes I'm kind of OCD about keeping my text lined up at exactly, for example, the 70 characters column. I care a lot about that, especially if I'm writing code or text that I want to also visually look nice. And I enable this. And let's see, I enable it for prog-mode. So yeah, I guess if I, for example, do this… This little thin line that we see here, that's the display filler column indicator. I used to have it globally enabled, but then I found that a bit too much, so I just enable it with a hook in the modes that I want.

Sacha: Yeah, and the theme makes it very subtle. It's just there as a reminder, don't go beyond this line. You can if you really want to, but just try not to.

Amin: Yeah, exactly. And then my essentials… This is where I configure a lot of key behaviours of Emacs, all built-in stuff for the most part, or things that are key to my workflows. For example, I always want to start with a *scratch​* buffer.

22:53 emacsclient for EDITOR and VISUAL

Amin: Start the Emacs server if it's not running. And this is very useful, very helpful so that then you can call into an existing Emacs process with emacsclient and have it edit a file. I don't use it for anything fancy just yet. I believe Prot also mentioned in his video with you, Sacha, that he uses it for things like org-capture to spawn a new buffer in his existing Emacs session and things like that. You can do pretty cool things with it. But yeah, I just use it for being able to easily use my Emacs as EDITOR and VISUAL text editors. So yeah, this sets that up.

23:37 fundamental-mode-hook

Amin: Adding a fundamental mode hook. Again, I took this from Prot.

Sacha: I was surprised by that because I was like, oh, there isn't a fundamental-mode-hook? Okay, that makes sense now.

Amin: Right, right. Yeah, there isn't a fundamental-mode-hook by design. But I still, in the past, have found that I wanted that. For example, for this display-fill-column-indicator, when I had it enabled everywhere, I was like, it would be nice if I could at least disable it for Fundamental mode. And at the time, I didn't have this. I added this just recently. So if I decide to go back to using something globally, but I don't want it in fundamental-mode, then I can disable it using this. Yeah, and then some standard stuff like I prefer spaces and a tab width of four characters.

24:23 indicate-buffer-boundaries

Amin: Visually indicate buffer boundaries. This is a little bit hard to see right now, but here at the bottom left

Amin: you see a little down arrow

Amin: and then the little top arrow. And… Let's see if I can.

Sacha: Oh!

Amin: And also here, for example, when it all fits in the view.

Sacha: Huh, that is cool. I was looking at that. What does it do? And so that tells you, you can still scroll up or you can still scroll down, and you don't have to look at the scroll bar to see where you are. It just says there's more there.

Amin: Yeah, exactly. Yeah. And it also helps distinguish when there's a newline character at the end of the file or not. So here in this buffer, there is.

Amin: But if I delete that, you see this indicator here changed shape. But if I go back and add the new line again. So yeah, that's also been very helpful for me because I added configuration files and some of these pieces of software are sensitive to having a new line at the end of the file. So yeah, it's very helpful and useful for that.

Sacha: I would not have guessed that from the very short line in your config that turns that on. It's one line, (setq-default indicate-buffer-boundaries 'left), and yet it adds this nice little nuance to the way that fringe looks.

Amin: Right. Yeah, absolutely. Perhaps I should expand more on it at some point later to explain these things. But yeah, just this one line.

Sacha: May I recommend screenshots?

Amin: Yes, you may, for sure. Yeah, I will definitely do that as well, because I'm also a bit of a visual person. I like seeing screenshots and videos, so yeah I'll take that to heart and do that for my own configuration as well.

Sacha: When I post this, I'll probably… I figured out how to have the transcripts and then screenshots embedded into my transcript. I'll generate it automatically from the subtitle file. Our EmacsConf transcripts are going to get so fancy next year. But you can pull those screenshots and drop them into your config. It'll be great.

Amin: Nice. Yeah, for sure. Sounds good.

26:36 enabling and disabling commands

Amin: And then here, I just enable some of these commands that are disabled by default. So yeah, it's useful, especially narrow-to-page, for example, or narrow-to-region. These are commands where Emacs disables them by default so that newcomers don't accidentally hit them and get very confused by what just happened. It doesn't disable them for good. It just basically prompts you for confirmation. Are you sure you want to run this command? I'm sure, at least about these commands. So I just enable them. And then something like, for example, overwrite-mode, which I never use and I don't want to accidentally enable. I just put it disabled so that if I do accidentally hit the keys, which might be, I don't know, something insert or whatever, then it will prompt me to make sure that I meant to do that.

Sacha: That reminds me, I should probably turn that off for myself and then you get a whole new keyboard shortcut you can use too.

Amin: Right, yeah. Let's see.

27:37 package-review-policy

Amin: Yeah, I have just one line setting for package.el. In Emacs 31, we will be getting a package-review-policy which is very helpful. So if you do use package.el for installing packages from GNU ELPA, NonGNU ELPA, MELPA or whatever else, you can enable this, and then whenever you update your packages, you'll get a diff of what changed in this new revision of the package that you're downloading and you're about to enable. And you can presumably say yes or at least see what's going on, which I'd find helpful.

Sacha: But you're not using packages, you mentioned, so you're just checking everything out and then you're just git pulling whenever you feel like it.

Amin: Yeah, so right now I'm using git pulls and git submodules, very manual. I put this here because I think it's generally a very welcome change and awesome new feature that I want to spread the word about. So maybe someone who's looking at my config, they use package and that's perfectly fine. So this is just here to spread the word about it mainly, I guess. And if I start using package at some point myself in the future, then I will have this enabled. Let's see.

28:52 getting the Info files from the Emacs source directory

Amin: Very quickly, here I extend Info-directory-list. I like to, at least on some of my machines, use Emacs that I built from source directly in the source repository of Emacs. Just after doing make, I don't run make install, even though it's very easy to do that. You can install to a custom location by providing --prefix when you're ./configure-ing Emacs. Sometimes I just find it more convenient for me to not do that and just run make and then exit and reopen Emacs. And for that kind of a setup, I just extend the Info-directory-list to include the info subdirectory of the Emacs source repository so that the built-in Emacs info manuals will be available to me.

29:45 recentf, adding directories

Amin: And then I use recentf for tracking recent revisited files. I bind it to C-c f r e for me to get a pop-up completion for visiting a recent file, it has completion. So if I hit TAB here, for example, we can see some of these files or directories that I visited recently.

Sacha: I see. And then you're adding the directory to it. So what does that let you do? Because I'm assuming you're already in there in the directory. But how does that change your recentf?

Amin: Right. So I need to think to remember this, but I think the point of this was that if I open a project in VC or in Dired, then I would like that directory to also get added to my recentf files list, because I think by default, recentf only includes files, not directories.

Sacha: You're in it, you start up Magit or whatever, and then you move on to something else, but you want to be able to easily go back to it.

Amin: Yeah, for example, I like to keep my recently visited directories in recentf as well. Because that's one of the main ways I jump between projects and stuff, even though there is literally a built-in Emacs project mode, which I still use. The only thing that I have here is… I don't want to add my home directory to the recently visited list, so the only thing that this function does is to skip that if I'm opening the home directory. That's about it.

31:38 Scrolling

Amin: And then here I configure mouse and scrolling behaviour. So I want Emacs to scroll very gently, one line at a time. I think the default is that when you reach the end of the page, it'll jump half a page down and then recenter. I don't remember default behaviour because I don't use it very much, but yeah, this basically makes it very predictable. For example, when I reach the edge of the page here and I press C-n, it'll only scroll one line at a time, instead of jumping and then doing something like this.

Sacha: Oh yeah, mine does! Mine doesn't do that, so it does that jumping thing. I see what you mean here. Interesting.

Amin: Yeah, so you can tweak that with scroll-conservatively and then scroll-preserve-screen-position, I believe.

32:28 auto revert

Amin: Yeah, and then I use autorevert, which is pretty helpful. So this will have Emacs watch, for example, files that are open in your buffers. And if they change on disk, Emacs will automatically refresh the buffer so that you get the latest version. The cool thing is you can press undo in one of these files that's been autoreverted so that you get the revision that was there right before the change. So I've used that sometimes as well.

Sacha: Yeah, and sometimes autofollow also is nice for log files and things like that. But yeah, autoreverting is great.

Amin: Yeah, for sure.

33:14 Repeat mode

Amin: repeat-mode is something that I've only recently started using, especially with my Emacs EXWM setup, using Emacs as my window manager. For example, if I hit C-x o, we see here in the echo area where it says repeat with o or capital O. So I can now only press o instead of saying C-x o, C-x o to do that multiple times. Keymaps that have support for this basically indicate that they want to be repeatable can declare that. And then once you invoke one of the keys in those keymaps, then you can repeat it with just that single character. And for example, for my setup, I have that with my EXWM workspace switching keys. So I can easily go to the next and previous workspaces, many of them at a time by just pressing p and n instead of doing the shortcut multiple times.

Sacha: And actually, if you don't mind jumping ahead, the EXWM part of your config is fairly complex, and I think not a lot of people have a lot of experience seeing EXWM in action. And I don't know whether you're comfortable sharing you switching around to different workspaces, but if that is something that you can do, how are you doing all this awesomeness? I'm still too scared to use EXWM myself. Stability. But that's a me problem, not an EXWM problem.

34:51 EXWM

Amin: Yeah, EXWM was pretty awesome. I used it back in 2018, '19 for a while, and then I kind of moved on to Sway and Wayland. But I don't know. It's something that I feel like once you try it, you want to keep going back to it. So recently, this past month or so, I decided to give it an earnest try and try to actually address any pain points that I've noticed. So it's much more usable for me now, and I'm sticking with it for now. I'm not a Wayland hater, but I'm just saying, at least for now, I'm using EXWM. And I'm happy to talk about it.

Sacha: OK, what do you love about your setup for that one?

Amin: EXWM?

Sacha: Yeah, yeah. Like, you're doing a lot of rename buffers. Yeah, yeah, yeah.

Amin: Right. Yeah, let me think. There's a couple of things. So, for the longest time, my Emacs EXWM configuration used super key as a prefix, which is the Windows [key] or the one with the logo, basically, to switch workspaces, launch applications and such. And at least the way that EXWM is right now, it doesn't… Like the way you have to add those global key bindings kind of slows down the EXWM startup. And I had many such key bindings.

Amin: So one thing that I did kind of recently is to define a prefix map here, like bandali-prefix-exwm-map. So I bind all of the keys and commands that I want here, and then this helps me really minimize what I'm telling EXWM, which is here. For example, this is how you set global keys with EXWM, and I just point it to my prefix map. C-c x and then any of those letters and functions that we saw. That's kind of annoying. I still use the super key here, but I have it s-x and s-,. On the left-hand side of my keyboard, x is right next to super, so I can hit it in one go with one motion almost as a single key with these two fingers. On the right side of my keyboard, I don't have a super key, but I have a control key that I remapped to super. On the right side, I do s-, with these two fingers. It's still very convenient for me to invoke those commands. And pairing this up with repeat-mode, as we can see just here, actually, then I can hit s-, and then p, n, or h, j, k, l many times to switch workspaces or shift focus to different windows and stuff without having to hit that kind of annoying s-x or s-, repeatedly. Yeah.

Sacha: That sounds really cool. I should look into that. Sorry, quick aside.

38:03 Audio setup

Sacha: @blaiseutube would like to compliment you on your awesome audio setup. It sounds like you're in the room with him. Apparently, I sound like I'm on speakerphone, but your audio setup is top-notch, apparently. But that looks like a Blue Yeti, so I have to find out what's going on. What microphone are you using?

Amin: It is indeed a Blue Yeti.

Sacha: Yeah, yeah. So I just have to ask him for okay, what kind of boom mic? Anyway, we'll do that all offline because it's not Emacs related.

Amin: Yeah, it's just the Blue Yeti. Yeah, I turned down the gain. I used to have gain higher, but then it picks up more noise from around the room or around the house. So I turned down the gain a lot and then I get close to the mic so that it only captures my voice. Okay.

Sacha: I'm gonna need the boom. Otherwise, I'm squished into that corner. All right. So you were doing repeat-map before I said oh, let's talk about EXWM because you've got cool stuff there.

Amin: Yeah, and I can continue talking about the EXWM. There's a lot here.

39:10 keymaps for launching different applications

Amin: I have, let's see, s-, SPC. I bind it to async-shell-command to use as my simple, little, dmenu-thing for launching applications.

Amin: Some of these things, like browsers, I still do them frequently enough, and I use different browser profiles. So I just define a new keymap so I can basically one-shot launch Chromium or Firefox in a specific browser [profile] or an incognito window and such. So yeah, I just do s-x b and then, for example, c to launch Chromium and all that stuff. So I found this pretty convenient.

39:49 bandali-call-interactively-insert

Amin: Speaking of key bindings, before I get down this, let's see if I can find… C-c h. I think this is just before my EXWM setup. I'm pretty proud of this. I love this. It really goes to show how awesome Emacs is and extensible it is. Let's see. So as we know, these various help commands and describe commands are under C-h prefix. But some of them are not bound, for example, find-library or describe-face. Some of these I use pretty frequently. I was really having trouble coming up with descriptive-enough keybindings or short-enough keybindings for all of them. I put some of them here, for example, like C-c f l for find-library. But I can't do that for all of them. What I did was just do C-c h a or C-c h d. What this will do is basically, if I show that, It basically opens up M-x, fills in describe-, and then I can just type, for example, face, and that's it. So it basically opens up the minibuffer for me, pre-fills it with the string that I want, and I can type what is it that I'm looking for. And I found this to be better than trying to bind a million different keyboard things for describe this and that, apropos this and that, find this and that. So yeah and the way that we do that is to just use a minibuffer-with-setup-hook, and you just have a little lambda to insert the string that you give it, and then you invoke it.

Sacha: Yeah, this is pretty cool. When I saw that in your config, I was like, I'm going to steal that. Pre-filling the minibuffer but still letting you do stuff with it, it's such a powerful thing, not just for completing the command itself, but even for when you're using the command, but you want to do something with the input before. You don't want to do it all the way, send it in and submit right away. You want to actually do something with it after you insert it. So great tip.

Amin: Yeah. Thanks. Yeah, it's pretty useful. It's pretty nice. Yeah. And then back to the Emacs or EXWM stuff. So before I had, I used to yeah, sorry, go ahead.

Sacha: Sorry. I forgot whether I was muted or unmuted.

Amin: Okay, no worries.

42:26 workspaces

Amin: For the longest time, I had 10 default EXWM workspaces on startup, and that can slow things down a little bit. So I found that okay, I don't really use all 10 workspaces always. So I set it to 5. So I get five workspaces initially. But I still bind keys here. Like if we go down. Let's see. Here. So here, I define those keys for all the way from, let's say, from 0 to 9 for all 10. And then if I try to switch to a workspace that doesn't exist, then EXWM will just go ahead and create it for me. Yeah, so I found that pretty cool. You can create workspaces on the fly. Yeah.

Sacha: Yeah, and I saw that it moves your current window there, too. So that's just like, OK. Let's move it to workspace number two or whatever. Very cool.

Amin: Yeah, yeah, yeah. I have keys or convenience keys for moving some window to some workspace. Yeah, it's nice. Let's see. Let's see. Yeah. So these are just made key bindings. I use hjkl here for switching windows.

43:46 ZSA Voyager split keyboard, super x as a single key

Amin: I also have a ZSA Voyager split ergonomic keyboard. I can basically customize it infinitely. For example, I don't really have a super key on the first layer. What I have is a key that will do the s-x thingy, basically, my prefix. So that's the last missing piece is that if I'm at home and if I have this keyboard with me, then I just hit one key and then that's it. I'm in my prefix. But even if not, on the laptop, the s-x or the super comma are still easy enough for me to hit it with one hand.

Sacha: Now I'm jealous and I definitely want to assign my prefixes to their own keys. Very tempting. I've started using the numpad because my laptop has one. I only use the numpad rarely, but we all need more keys.

Amin: Yeah, ergonomic keyboards are pretty nice, especially these ones. For example, the ZSA ones where you can put QMK on it, the QMK firmware. You can define keys in a C file. I can actually show that. Let's see… QMK Firmware, Keyboards, ZSA, Voyager, Bandali, and then keymap.c.

Sacha: Is this in your repository somewhere?

Amin: Right. It's in a different repository, but it's still on https://git.kelar.org next to my configs repository. You can find this as well, but if I go smaller… Yeah, you can define keys here and have different layers, like the base layer. And then you can define a key to switch between different layers and put some of the keys there anyway. So yeah, it's a whole rabbit hole in and of itself. Prot also uses a split ergonomic keyboard. It really does help if you're typing for long periods of time. I actually had these for a while, and I wasn't using them too much, but I started slowly getting some pain in my wrists and here. So I was like, okay, I have the keyboard, might as well put it to good use, and I've started using it.

46:26 Keybindings

Sacha: Okay, so most of your keyboard shortcuts come off that kind of s-x or C-c something, and then you have a long prefix sequence, and you just remember everything or you use your… pre-fill some of it and then fill in the rest of the command.

Amin: Pretty much all my window management related keys are on this s-x prefix that I'm showing here. And then I have a few other ones which I think I showed earlier. Is it this one? Anyway, I bind a few general keys outside of the s-x thing, like C-c e i. For example, I have C-c e e for eval-last-sexp. I do that a lot, so it's easy to hit that. Making frames or deleting frames.

Sacha: I love how Emacs uptime is something you use frequently enough that you have a keyboard shortcut for it.

Amin: Yeah, of course. I mean, I'm sometimes curious to see how long has my Emacs session been running. To continue with the EXWM stuff, let's see. This is just some keybindings I define here. It's all Emacs Lisp, right? It's amazing. You can mapc over whatever sequence and create keybindings like that. Only with Emacs we can do things like that. I just love it. Let's see.

48:05 Media buttons

Amin: I still keep these three other keys for raising and lowering the volume and toggling mute off of that prefix and just directly on my keyboard, hitting it directly in the exwm-input-global-keys because I do that very, very frequently. But I also have scripts that I can invoke. I should do keycast. So yeah, I can invoke the prefix with semicolon. I can set my volume here, adjust it here, type in what volume I want, or with the single quote, I can enter a value for the screen brightness. I like these things to be exact depending on the lighting in the room. I have preferred brightness values of 50 or 12 or 10 that I manually adjust. I guess it's a poor man's version of having something with a light sensor that can pick up and adjust automatically. I do it manually. Yeah. Sorry, you just muted yourself again.

Sacha: You're just probably this close to writing the Emacs Lisp that takes your webcam image and then adjusts your light. But I think Prot was also saying he likes to do the lighting changes manually as well because warmer colors versus cooler colors and all of that stuff. Anyway, so you have all these buttons that EXWM listens to and it can launch various things for. That's a lot of things.

Amin: Yeah, those are pretty cool.

49:43 exwm-input-simulation-keys!

Amin: EXWM has this lovely feature called input simulation keys where You can basically use it to bring Emacs key bindings to other applications like Firefox or whatever. And yeah, it's mind blowing when you try it for the first time. for example, I bind C-b to just hit the left arrow on the keyboard. And it does that. So I can define all of these commands that I'm using or used to using in Emacs. So I can get them in Firefox or other applications as well. Realistically, it's mostly Firefox. It's the only other program that I spend any reasonable amount of time outside of Emacs.

Sacha: Let me point out this very important one that you have there. Under selection/cut/copy/paste, I see a C-w input simulation key. So this is for all the people who have accidentally closed their browser tab while trying to copy text. This is how you solve that problem. Use EXWM and use EXWM input simulation keys and you don't have to accidentally close your browser tabs again. @blaiseutube asks, hey, what about time since last save? Or do you have some kind of autosave magic? you know, in reference to the uptime thing, right? You have this thing that shows you…

Amin: I don't think I have anything for autosave, but I have this habit of… I save everything pretty regularly. Yeah, so I've never really needed that feature, but I'm sure Emacs has something where you can, at the very least, just very dumb, simple implementation of has it been idle for one minute, then just do a save buffer. You can roll your own. But I don't have anything.

Sacha: All right. I'm getting really tempted now to try out EXWM, even if it's just for those global keyboard remapping things.

51:39 exwm: managing floating windows

Sacha: How is it for windows that you've got to have floating? I feel like it's very good at handling tiling things, but how is it for sometimes the apps kind of really want the floating window?

Amin: Right, yeah, so you can toggle any window to be floating or not, and you can also - actually, we're just looking at it here. EXWM manage configurations, to match on the instance name or the class name of a window that you can get from xprop, to automatically make that tiling. For example, if I do my prefix and then capital T, it launches a floating terminal for me here. And if I go back to where I set it up, I just launch Xterm with the -name argument. This is where it can set the instance. And I just put any string you can want, like floating, for example. And then here in my configuration, I just check that if the instance name is floating, then I'll go ahead and float the window. Simple as that.

Sacha: All right. This is starting to look exceedingly tempting. Lol, I save everything regularly, so he's one of those people who compulsively hit C-x C-s.

Amin: Yeah, I do that a lot. I don't know. It's just me. But, yeah. Yeah. And then, I don't know. EXWM is awesome.

53:11 exwm: application-specific local simulation keys

Amin: You can also put local simulation keys, application-specific simulation keys, depending on, the application, terminals, for example, or, Zathura. This is a PDF viewer. To have application-specific custom key bindings, how cool is that? For example, if I'm in Xterm or something like the Mate terminal, hitting C-c C-c twice basically, it'll just send the C-c key to the terminal. Because one thing with EXWM is that you can set it to capture a couple of Emacs prefixes, like C-x or C-c. So the application by default doesn't see it because Emacs captures it. But this is one of those mechanisms by which you can send a key through. Let's see.

54:04 binding C-q to exwm-input-send-next-key

Amin: The other thing is, you can set it like EXWM inputs send next key. So the default is C-c C-q, but I just bind it to C-q, and I, for example, can do C-q C-t to send C-t to the underlying application. So that's the other thing. Yeah, and then let's see.

54:28 Renaming buffers

Amin: So this thingy here, I enable EXWM and I add this rename hook and all it does is basically to add the window titles to the buffer that I can see on the mode line. But as long as it's within a certain reasonable length, like for example, I have 25 characters. If it's longer than that, it will just put dot dot dot (...). So yeah, that's all the purpose of that. Let's see, for example, if I launch Xterm, it appears there. The perfect example is actually here on the right-hand side. On the mode line, we see Firefox ESR Emacs Chat. It's a bit long, so it just puts the dot dot dot there. So that's all that does.

Sacha: Yeah, now being able to use Emacs to manage the tiling of these things instead of my having to fiddle with alt-dragging things to snap nicely into buffers. Yes, very cool stuff. EXWM. Gotta try it.

Amin: Yeah, for sure. Yeah, let's see.

55:36 dunst for notifications

Amin: Here I launch Dunst if the executable is installed for getting notifications in EXWM. I think there's at least one or two Emacs specific packages that implement a simple notification daemon or backend so that Emacs itself can handle that. But I found Dunst good enough for my use cases coming from i3, Sway, like tiling window manager background. I just reuse that. So yeah, I just start a process, keep a handle of it in this bandali--dunst-process variable here. And this thing I discovered recently, it's cool. using set-process-query-on-exit-flag, you can basically have Emacs not ask you if you want to exit Emacs if that process is still running. It'll just kill it without confirming with you. So just a little convenience.

Sacha: That is also cool. Just a heads up, I have about 15 minutes before the kiddo runs out because she'll be done with school then. Even just the EXWM part and other things that you've shown us in the config have been super awesome. But are there other things in the next 15 minutes that you would love to show people so that they can see how it works in practice?

56:54 exwm xsettings and responding to screen configuration changes

Amin: One thing I'll just mention, EXWM, one more thing, and then I'll go check. I think this is kind of recent: EXWM xsettings, and this allows you to dynamically at runtime change some of these things that you would normally set in an X resources file, like fonts. These kinds of settings were especially commonplace back when Wayland wasn't a thing or wasn't very popular. You would set some of these font settings there. With EXWM xsettings, you can do this dynamically, and what's awesome about that is it also lets you hook into, for example, if your screen configuration changes, if you plug in a monitor or unplug it, then you can run whatever xrandr command to set it up and also adjust those settings. The main thing I use it for is to change the DPI setting. The thing with X11 or Xorg is, unfortunately, there's no per-monitor DPI. There's one global DPI. But I found that on my high-DPI laptop screen, if I set the resolution to 1920x1080 instead of the full resolution, then the default DPI of 96 works just fine with my external monitor as well. All this little hook does, by calling into this function, is: if I'm plugging in my external monitor, lower the resolution and lower the DPI, and if I unplug it, go back to the high thing. I just love this.

Sacha: That's great. We're definitely not going to demonstrate that because plugging in and unplugging monitors is not a good thing for screen sharing, but that sounds really cool. When things change, you can actually get your system to adapt to the changes for you.

Amin: Yeah, it's lovely. Let's see. There's so much more to talk about.

58:59 Slowly getting back into Org mode

Amin: I'm slowly getting back into Org Mode again. For the longest time, I didn't use it and I just used Markdown for my website as well. But I found that it's kind of limited. For example, I was using a Markdown implementation that was written in C and I can't easily customize it. Whereas with Org, I can hook into or create my custom HTML backend that's a derivative of ox-html, even if I don't necessarily like the defaults or the settings for ox-html. I just recently started writing a new backend called bhtml for Bandali HTML. It's just a boilerplate. I don't have much there yet, but that's the idea.

Sacha: I love how you can hook into all of these different aspects of Emacs and get it to do exactly what you want.

Amin: Yeah, so that's cool. Let's see.

59:58 chat notes

Amin: I have written some things about the prompt for this meeting. Yeah, so I talked about that stuff briefly. Minibuffer setup. Things that I love about my setup is that it's kind of portable, simple. People can easily copy things from it if they want. It's kind of self-contained. And that was kind of a big thing a while back when I wanted to use my configurations on a couple of work machines. And these don't have direct outbound internet access. So I couldn't do things like installing packages with ELPA because that's done over HTTP. So yeah, I use submodules now. I recently began documenting my setup, very much inspired by Prot and Sacha and others.

1:00:52 Mode line

Amin: The things that I'm looking forward to tweaking next is the mode line. This is basically the default mode line of Emacs. A couple versions ago, they added a setting for compacting the mode line, which improves a lot of the extraneous whitespace in it, which is great. It's still… There's too much information. If you use multiple windows or even especially if you use EXWM all of those things like the date or like the battery get repeated in all of the windows, so I'm looking forward to doing my mode line in such a way that for example, it shows most of those things. And Prot actually has an excellent video about that where he shows how you can create your own custom mode line.

Sacha: I've also been tempted to start using the header line too because that's another thing that you can put information in.

Amin: Right, yep, header-line is awesome.

1:01:49 display-buffer-alist

Sacha: Yeah, the display-buffer-alist is particularly powerful because you're combining it with EXWM, so it'd be interesting to see how you can manage windows and applications and stuff.

Amin: Especially, just like how we saw in today's video call and also a call that I had with Prot recently. For example, if I open a describe-variable or something, it'll by default use the right area of the screen right now where our video is. So it reuses that. So I'm also looking forward to reading more about and configuring display-buffer-alist.

1:02:23 TRAMP slowness, maybe disabling VC detection?

Amin: I'd like to figure out some TRAMP slowness. I recently tried using it again. It's awesome. You can seamlessly open files, SSH into other machines and edit files there. But I don't know. It's kind of slow. So I want to see aside from the latency, you know, the physical limit of the latency because of the distance. Is there anything slowing it down? I think I read in the Tramp FAQ that maybe trying to disable VC mode or VC detection for remote connections might help speed it up, or at least having it do only Git, for example, because by default, Emacs's VC has support for Mercurial, CVS, SVN, Git, RCS even.

Sacha: Anything anyone has ever wanted to use in the last 40 years. Here we go. I saw in your chat config actually that you were doing something with the SSH configs and I'd never come across that. So I was like, oh, that's something I should look into later.

Amin: I don't remember the specifics, but it's all out there. Feel free to look into it.

1:03:39 eat

Amin: Especially with this EXWM setup, I still use Xterm sometimes and I have the Emacs EAT terminal, which is a terminal emulator written in Emacs Lisp. If I launch it right now, it's awesome. It actually is very powerful and it's a properly capable terminal emulator. It just can be a little bit slow. It is slower than xterm, but it's still a lot faster than whatever Emacs has built in. So this is pretty cool. But yeah, I don't want to use it a lot. And I kind of started testing, delegating more things or using more async-shell-command to just basically open this prompt and then do whatever I want. anyway.

Sacha: I've also heard things about Ghost TTY. Anyway, so that's another thing to look into. Yes, so @Paniash47 says, "With Emacs 31, there's a new variable where you can hide the minor modes in the mode line." @pkal says it's mode-line-collapse-minor-modes. And @Paniash47 also says, "I personally use the Minions package by Tarsius, and it has some nice features in addition to the built-in features." So other people are tinkering around with their mode lines as well.

Amin: Yeah, it's pretty cool. And then I don't know, I think maybe you touched on something a couple of minutes ago that I was going to go back to, but I forget.

1:05:07 TRAMP completion

Sacha: Tramp SSH completion out of your configs. I was like, there's a Tramp sconfig in here that I've never used. And that sounded interesting. Yeah, tramp-parse-sconfig.

Amin: Ah, right, right, right. Yeah.

Sacha: Which, of course, we're not going to let go because it's private stuff, but yeah.

Amin: Right. Yeah, you're welcome to try this. I'm pretty sure, actually, I took this from the Tramp manual itself. And it's one of those things where it's set and forget, I don't remember. But yeah, it's here. There was something else that I also wanted to show, but I forget. Let me see if looking at the outlines will remind me or if I will see it.

Sacha: And that's one of the things I love about literate configuration is, you know, just kind of look at the structure and skim it and try to find something with keywords and ordered lists and all that stuff.

Amin: Right. Yup. Exactly.

Sacha: Oh, and you know, people will have access to your full configuration because it is in your repository and you have that lovely HTML export for it as well. So if you, uh, if, if people want to follow up, they can go through that at length. At some point, you're going to add some more screenshots and possibly even video clips to it. so that's there you at https://git.kelar.org

Amin: This is my configurations repository. If you go here to treeview .emacs.d, this is the org file. I also export all of those individual components into this lisp subdirectory. All that stuff is here. The QMK thingy that was mentioned.

1:06:54 ffs: form feed slides, ^L

Amin: Oh, I wanted to mention FFS. Okay, I'll do that as well. Yeah, what's up with that?

Sacha: I was trying to find information. It was like, there's no package. It's not what is this thing?

Amin: It's FormFeed Slides and it's going to soon be a package. I was actually talking to Prot about it and I'm hoping to submit it for inclusion in GNU ELPA within, I don't know, the next couple of weeks. It's basically very similar to Prot's Logos package. Turns out we both had the same kind of idea at the exact same time in 2022, and we both used it for our LibrePlanet 2022 presentations. Of course, Prot being the diligent person that he is, he polished his work, documented it, put it on GNU ELPA. I still haven't gotten around to doing it yet, but better late than never. Yeah, let's see. I can maybe show a quick demonstration of that. So let's see. Let's see. Anyway, so if I go to my website sources and net-beyond-web. So I had the LibrePlanet talk a couple years ago. So what FFS is basically, it looks for a particular character in this case, or the default case, it's the page-delimiter, ^L, which you can insert by hitting C-q C-l. It basically then designates each of these areas as one slide. So, very, very simple slideshow that you don't even have to use Org or outline or any other major or minor mode. If I launch ffs, by default, it's in a mode where it binds a couple of convenience keys, like p and n, to go into the next and previous slide. You can hit e to edit a slide, similar to Org source, and then make your changes and all of that. And then you can start a presentation by hitting s.

Amin: It has hooks for, for example, bumping up the font size or whatever, hiding the mode line. I can toggle the mode line by hitting m here. Let's see. I can also toggle the cursor with c, to make the cursor visible or not. So, yeah. And then I'm just hitting p and n.

Sacha: Very simple, very minimalist. You have a file, you've got page markers, and that's all you got.

Amin: Yeah, pretty much. And then…

1:09:34 Speaker notes

Amin: The neat thing that it has that I also liked implementing at the time is it has a speaker notes feature.

Amin: So you can designate a file as being the speaker notes where it has the same structure separators with ^L. But you can type your notes over here, whatever. And you can basically open these in two different windows or two different frames on separate displays. And then in whichever one of those you advance the slides, like p n n, it also does the other one.

Sacha: That's brilliant. I was looking for a way to do that so I can pretend to know what I'm talking about when I have something on screen, but I can just read my notes or even just remember what points I wanted to make. So this is great. You have speaker notes. You've got the main screen. They can be in two different frames. You can have your frame that you're sharing and your frame that you're not sharing that has all of your cheat sheets. Excellent. And on that note, in about one minute, the kid is going to come running out and want to have snack and all that stuff. Thank you so much for walking through parts of your config. There is more. And so everyone who wants to find out more can go check out your setup. I have a great many things that I want to try out, starting from EXWM to little things like figuring out a boom mic setup because apparently your audio setup is making me very jealous. Yes, thank you for doing this. I'm going to post the transcript and the chapters. I have a chapter every minute. It's going to be a long time. But it was good. Lots of cool stuff. Thank you again.

Amin: Sounds great. And yeah, you're very welcome. And thank you so much for having me as well, Sacha. I'm very delighted to be here, especially, I think, just by chance. I think I'm the first person who you're doing this with after the long hiatus. So that's an extra honor for me. But yeah, it's been fun. I could go on for hours. I'm sure we both could. This has been fun.

Sacha: If we wanted to go on for hours, Prot has more flexible scheduling, so he can chat with people for two hours and stuff, and you already have conversations going on with him. But I unfortunately have a small mammal who's 10 years old and loves me very much, and likes to not let me concentrate for very long. But thank you everyone for joining. Thank you for the chat. And thank you also, stream, for all the interesting questions. I will send you all the information and update the post. And we'll see you all on Thursday. I've got another chat. All of a sudden, all these Emacs chats are going to happen. Thanks. Oh, and you said you're happy to be on the hook for doing another EmacsConf this year, right?

Amin: Yes. You can hold me to that. There will be another EmacsConf this year and I will be active in it.

Sacha: Alright then, I'm going to end that broadcast. Thanks everyone, bye!

Amin: Thank you, bye bye!

You can comment on Mastodon or e-mail me at sacha@sachachua.com.

Someone recently said on emacs-devel that they'd like to talk about recommending ELPA packages. Someone else said we should first ask what "recommending" actually means. RMS opened a thread asking that very question. It's still open, and you can follow it there (ELPA: to curate or not to curate).

I think we could apply Rich Hickey's technique here and start by looking up the definition of "recommend" in the dictionary. I invite everyone to do so with whatever dictionary you have at hand and to trust your definitions.

Now, we could evaluate ELPA packages for recommendation based on whether they complement or improve functionality already present in the core. For example, diff-hl by Dmitry Gutov. Its description says:

diff-hl-mode highlights uncommitted changes on the side of the window, allows you to jump between and revert them selectively. In buffers controlled by Git, you can stage and unstage the changes.

That last feature —staging partial hunks— is missing from VC, and diff-hl adds it seamlessly. We could say diff-hl complements the core.

Then there are major mode packages, like csv-mode, markdown-mode, cobol-mode, and so on. They add functionality that doesn't exist in the core. They have no direct equivalent. We could call them standalone packages.

Now consider another excellent package, like diff-hl, that depends only on the core: expreg, by Yuan Fu, the region expansion package. With a single key, it expands the region based on context. The core already offers this through sexp movement commands, but not with a single keybinding — you need several. Some will prefer the native core way; others will prefer the package. We could say expreg improves or, depending on how you look at it, duplicates the core's functionality.

So, in my opinion, package recommendations should be structured around their relationship with the Emacs core. I believe the best-regarded ELPA packages should be those that encourage users to use what the core already offers, first and foremost, and then try those packages because they extend a feature the core lacks or complement it. This would also help more people discover lesser-known core features, increase bug reports, and, over time, bring more contributors to Emacs. That way, the Emacs community could have a package repository it can trust for as long as Emacs exists. Perhaps the person who wrote Elfeed would have known about Newsticker and would have contributed to that package instead. Perhaps if we recommended what Emacs already offers, the Elisp we write would be Elisp of and for Emacs.

You can e-mail me at sacha@sachachua.com.

It's May and I like puns, so I'm going to suggest "May I recommend…" as our Emacs Carnival theme this month, building on lively conversations about people's favourite packages on lobste.rs, Reddit, and Hacker News. Let's go beyond packages and talk workflows, tips, practices, perspectives… whatever you'd recommend!

It was pretty nice having a wiki page that people could edit without needing to wait for me, so if you write about this topic, feel free to and add your link. If you run into problems doing that, please e-mail me and I can add the link for you.

People have already started sharing their recommendations:

• May Emacs Carnival
• May I Recommend EWM | Dilip's Log
• From David Dimagid: What we talk about when we talk about recommending Emacs packages

I'll also do a round-up post at the end of the month so that it shows up in people's RSS feeds.

Looking forward to seeing what y'all recommend!

You can e-mail me at sacha@sachachua.com.

Thanks to everyone who shared their thoughts on the April 2026 Emacs Carnival theme of Newbies and Starter Kits. Check out that post to see all the entries people have shared so far. I enjoyed chatting with Prot about the topic, and he shared some defaults that even experienced users have been trying out. The carnival theme for May 2026 is "May I recommend…". Looking forward to reading your posts!

• Upcoming events (iCal file, Org):
  • Emacs.si (in person): Emacs.si meetup #5 2026 (v #živo) https://dogodki.kompot.si/events/b4192df7-3da4-41b8-95a3-532b93923656 Mon May 4 1900 CET
  • EmacsATX: Emacs Social https://www.meetup.com/emacsatx/events/314341747/ Thu May 7 1600 America/Vancouver - 1800 America/Chicago - 1900 America/Toronto - 2300 Etc/GMT – Fri May 8 0100 Europe/Berlin - 0430 Asia/Kolkata - 0700 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri May 8 1800 Europe/Paris
  • London Emacs (in person): Emacs London meetup https://www.meetup.com/london-emacs-hacking/events/314540885/ Tue May 12 1800 Europe/London
  • Emacs Berlin: In-Person-Only Emacs-Berlin Stammtisch https://emacs-berlin.org/ Tue May 12 1900 Europe/Berlin
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed May 13 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu May 14 0000 Asia/Singapore
  • Sacha Chua: May 14: Sacha, Prot, and Philip Kaludercic Talk Emacs: Newcomer Experience (Protesilaos)
• Beginner:
  • Sacha Chua: What's in the Emacs newcomers-presets theme?
  • Sacha Chua: Working on the Emacs newbie experience
  • Protesilaos: Emacs: decent defaults I shared with Sacha Chua (Irreal)
• Emacs configuration:
  • Must-have Emacs packages you should know about [Updated]​ (Reddit)
  • Jiewawa: Overriding keybindings with Meow
  • Magnus: Follow-up on switching to eglot - more about use-package
  • Emacs config (15:08)
  • badele/idem: Doom Emacs configuration for DevOps workflows (bash, go, json, python, terraform, typescript, etc…) (@jesuislibre.org on Bluesky)
  • Sharing my emacs.d while cleaning up my folder a bit. (Reddit)
  • My Emacs Config (Reddit)
  • Been working on my emacs config lately (Reddit)
  • My configuration and workflow for game development in emacs with Godot
• Emacs Lisp:
  • Contributing to ELPA (@pkal@social.sdfeu.org, Reddit)
  • compat 31.0.0.0 released, stabilization in progress (@minad@mastodon.world)
  • Dave's blog: Writing an automated test to try to find an Emacs bug
  • NeLisp v1.0 — Emacs Lisp implemented in Elisp, plus a small Rust runtime that runs it without Emacs (Reddit)
• Appearance:
  • modus-flexoki (Reddit)
• Navigation:
  • nfdn: Bulk Search & Replace Commands for Files and Buffers in Emacs (Reddit)
  • Sidetabs using side windows. (Reddit)
• Writing:
  • How I use quick-sdcv to get the Oxford English Dictionary in my Emacs
  • Dave Pearson: blogmore.el v4.3.0 - blogmore-toggle-invite-comments, blogmore-invite-comments-to
• Denote:
  • New package: denote-wordcloud (Reddit)
• Org Mode:
  • Stupidly Simple Notes Taking With Emacs - Linux Renaissance (@darth@watch.linuxrenaissance.com)
  • I built an org-mode weekday repeater, .+wd
  • Jonathan Chu: Introducing grove.el - note-taking workflow for Org
  • Experimental/personal PDF-viewing/notetaking minor mode I (sort of) vibe-coded. (Reddit) dired + pdfview + org
  • Import, export, and integration:
    • Implementing a minimal evergreen blog in HTML and Emacs Lisp (Reddit, HN)
    • Randy Ridenour: Managing Multiple-Choice Questions With Org Mode
    • jamesendreshowell/org-teach-worksheet: Emacs lisp and Org macros for authoring classroom worksheets - Codeberg.org (@jameshowell@fediscience.org)
    • schue/org-canvas: upload Org mode files directly into an instance of the Canvas LMS. (@schuemaa@ecoevo.social)
    • canvas.el/canvas.org - interact with the Canvas learning management system (@locallytrivial@mathstodon.xyz)
    • De Org-mode a Trilium Notes, pasando por Obsidian · El blog de Lázaro (@elblogdelazaro)
    • tykayn/orgmode-to-gemini-blog - Source Bliss: Comme dirait Manon, les sources, c'est important. (@tykayn@mastodon.cipherbliss.com)
• Completion:
  • History: delete old duplicates, but still rank by frecency (@minad@mastodon.world)
  • vertico-posframe-preview: a preview sidecar for vertico-posframe (Reddit)
  • VOMPECCC from Scratch: Picking Fruits and Veggies with ICR (YouTube 51:06, Reddit, HN) - incremental completing read with vertico, consult, marginalia, etc.
• Coding:
  • Code to run magit-status on a project (@robjperez@fosstodon.org)
  • Wireframe.el Keyboard-first wireframe prototyping inside GNU Emacs.
  • Auto-mark rules, snooze, marking and filters for GitHub notifications in Emacs (Reddit)
  • eglot, emscripten, and clangd (@robjperez@fosstodon.org)
  • Einar Mostad: Fix Emacs python-mode REPL and org code block with python evaluation problems
  • uv.el – a declarative Emacs interface for the uv Python package manager (experimental) (Reddit)
  • Magnus: Secrets when connecting to DBs
  • Using our new Lua debbuger: LuaProbe, we made an Emacs package for it (Reddit)
  • Package announcement: go-prettify-mode.el (Reddit)
  • Emacs is a fantastic SQL editor - see the comments for more recommendations
• Mail, news, and chat:
  • Dave's blog: Browsing URLs from Gnus Summary buffer (Irreal)
  • Emails in Emacs (speziell Proton Mail) | Jan Iversen (@razorback@nerdculture.de)
• Evil mode:
  • Magnus: Jumping to errors in Evil
• Multimedia:
  • James Dyer: A Tiny Header line Tweak: Image Dimensions in image mode
• Fun:
  • Server play support in nethack-el: Help lobby for support on popular Nethack servers
• AI:
  • macher-agent: Similar to gptel-agent but within the macher context (Reddit)
  • adds $ completion for Codex skills in agent-shell buffers (Reddit)
  • Agent's major mode kit (Reddit)
  • Emacs manager for OpenAI Codex conversations (Reddit)
  • anvil.el v1.0.0 — first stable, anvil-ide split, anvil-pkg sister, and a no-Emacs path via NeLisp (Reddit)- let AI agents use Emacs as a workbench via MCP
• Community:
  • Emacs Carnival April 2026:
    • Free Software Tools: How I got into Emacs (and Free Software) (@len@toot.si)
    • Eric MacAdie: Emacs Carnival: History and Thoughts on Starter Kits
    • Sacha Chua: YE24: Sacha and Prot Talk Emacs - Newbies/Starter Kits (YouTube, 1:05:10)
      • YE20: Emacs Carnival: newbies / starter kits (01:03:50)
      • YE23: Explore Emacs starter kits and other resources (59:26)
  • Emacs Carnival in May (and in general) (Reddit)
  • The gravitational pull of Emacs — baty.net (@jbaty@social.lol)
  • Kent Pitman and Ramin Honary join on #commonLisp #lisp #IDE #emacs #schemacs #UX #lispyGopherClimate - toobnix (@screwtape@toobnix.org)
  • SimHacker/NeMACS: UniPress Emacs 2.20 for NeWS · GitHub (released 1989) (@kickingvegas@sfba.social)
  • Kent Pitman #demo 1977-1984 #MIT #ITS #DDT #TECO #EMACS #LISP #MACLISP - toobnix (@screwtape@toobnix.org)
  • A Report on Burnout in Open Source Software Communities (2025, PDF) (@yantar92@fosstodon.org) - not Emacs-specific, but good to think about long-term
• Other:
  • Emacs 30 Now On Android - Linux Renaissance (@darth@watch.linuxrenaissance.com)
  • Make Emacs inhibit logout in GNOME shell (@cidra@mastodon.uno)
  • Protesilaos: Emacs: save any buffer as PDF (my new buffer-to-pdf package) (YouTube 11:08, Reddit, Irreal)
• Emacs development:
  • The emacs-31 branch will be cut in one week (Reddit, Irreal)
  • Demote 'completion-preview-is-calling'
  • Project prompters always default to current project, if any
  • New variable 'completion-preview-is-calling'
  • Always compile w32image.c on MinGW (Bug#80924)
  • New VC commands for remote unintegrated changes
  • New commands to report diffs of all local changes
• New packages:
  • emcp: Lets your agent talk to Emacs (MELPA)
  • forgejo: Emacs Forgejo Front-end (GNU ELPA)
  • grove: Obsidian-like note-taking for org files (MELPA)
  • keymap-popup: Described keymaps with popup help (GNU ELPA)
  • mysql: Pure Elisp MySQL wire protocol client (MELPA)
  • outline-stars: Outshine-style star headings for outline-minor-mode (MELPA)
  • simulacrum: Inject custom event types into the event stream (MELPA)
  • sql-bigquery: Adds BigQuery support to SQLi mode (MELPA)
  • tmux-csi-u: Tmux CSI-u decoder (MELPA)
  • ttx-mode: TrueType/OpenType font viewer using ttx (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, 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 e-mail me at sacha@sachachua.com.

Tools

• I get the sense that there are going to be more applications like this. I Shipped a macOS App Built Entirely by Claude Code Indragie Karunaratne
• This made me laugh. Emacs elevator pitch. I agreed with the pitch, but it still made me laugh.
• Jack and I do share this trait. I think I need a workflow intervention (aka Stop Leaving Emacs) Baty.net. I fight the urge with the acknowledgment that even in this alternative to Emacs I will try to press the Ctrl + Spacebar to set a mark to select a section. The Emacs keybindings have fused themselves into my fingers and I feel lost without them. But the urge to switch is a real thing.
• I go through my application folder and sometimes I have no clue what the program I am looking at does. I blame it on this blog. To come up with content, I have to try a whole host of programs and I forget what they are supposed to be for. This is an attempt at keeping some control over the content of your application folder. macAppLibrary · coefficiencies
• stoicswe/minimalist: Minimalist text editor for macOS.. This is not bad. I prefer Coteditor for this task. Minimalist might appeal to some of you. Check it out.
• An entry into the “second brain” product category. Tolaria — A second brain for the AI era. It is free and open source.
• Loren came to the same conclusion I did. Done with Medium. Control your own content on the web. The service I use, Blot.im, is cheap and fantastic. There are a lot of other solutions available for the non-technically inclined. Stay away from people who want to monetize your content for their own wallets.
• Markdown Ate The World. I found myself agreeing with this article. I use Org-mode for my personal documents. It is similar to Markdown, in that it is syntax applied to a plain-text file. At the end of it, it is just that, a plain text file.
• Monarch - The Productivity Engine for macOS. Looks interesting. I plan to try it out.
• The field of launchers is getting competitive. I use Alfred. There are a host of other competitors. LaunchBar, Raycast and QuickSilver are still in the marketplace. Tuna is a new application which is in beta. My hesitation to try out Monarch is based on the realization that I am used to Alfred and it seems to do all that I need or can think of. Makes it difficult to summon up the energy to try something new. SOL - Open Source MacOS Launcher, is a free and open source competitor. I haven’t tried it out, you can, and let me know how you like it.
• FINAL|FINAL - A Writing App for Academics. This is an app I am keeping a close eye on. Has potential, but it is alpha software so tread carefully.
• Zed — Your last next editor reached version 1.0. It is good. Their focus is on developers and AI. I think they ignore writers for the most part. I like it better than VSCode.
• Notepad++ for Mac: Free Native macOS Code Editor got released. There are ex-Windows users who were waiting with bated breath for this. I don’t get it. There is Zed, BBEdit, Coteditor, SublimeText, and VSCode, to name only a few. What is the lure? I downloaded it and will write up a review of it one of these days.

Update: There are some legal issues associated with the Notepad++ product I talk about here. Trademark Violation: Fake Notepad++ for Mac | Notepad++. The original author says that the macOS version is an unauthorized clone. I am not going to cover this product. The macOS version has been renamed to Nextpad. Sounds shady as fuck.

That is all I have for today.

macosxguru at the gmail thingie.

Note: Thanks to Skylar Kang for the picture.

Recently I realised that it'd be really nice if jumping to errors would store the previous location in the Evil jump list. These definitions do just that

(evil-define-motion mes/evil-goto-next-error (count)
  :jump t
  (unless (bound-and-true-p flymake-mode) (signal 'search-failed nil))
  (flymake-goto-next-error count))
(evil-define-motion mes/evil-goto-prev-error (count)
  :jump t
  (unless (bound-and-true-p flymake-mode) (signal 'search-failed nil))
  (flymake-goto-prev-error count))

and for now I've bound them to C-j and C-k (because that's what evil-collection does)

(general-def flymake-mode-map
  :states 'normal
  "C-j" 'mes/evil-goto-next-error
  "C-k" 'mes/evil-goto-prev-error)

This makes it easier to make a change, fix the errors caused by the change and then return to where I was.

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

On the 14th of May we will meet with Sacha and Philip to talk about the upcoming Emacs 31 and other developments heading into Emacs 32. Philip is a contributor to core Emacs and the main driver behind the new newcomers-presets theme, among others. We will cover themes related to the newcomer experience.

I am looking forward to it!

This is an excerpt from an exchange that I am reproducing with permission from my correspondent. I am not sharing their contact details.

As I understand, you’re using the regular keybindings in emacs. I’m trying to transition away from the vim way of editing text and was wondering if you’re using a more ergonomic approach for your text editing needs. I remember you were using some ergo split keyboards for that?

Indeed, I have a split mechanical keyboard (a gift from a person who identifies as “Andreas”). It is the Iris revision 8 by Keebio. I also have a regular full-sized keyboard (a gift from Arialdo Martini), which is the Keychron K5.

[ Keyboard-related articles of mine: https://protesilaos.com/keeb/. ]

The split keyboard is nice, though it is not a magical solution. Even with a regular form factor keyboard, I can work with the standard Emacs keys without any problem. What helps me the most is to configure one-shot modifiers. This means that I can tap (press once, then release) a modifier key, then tap a regular key to register it as a modifier+key event. For example, C-x is this: tap Ctrl, then tap x. Shift tapping is especially nice for prose, by the way, and eases the pressure on the otherwise weak pinky. The time window for registering a one-shot modifier is configurable.

The other useful tweak for a regular keyboard is to rearrange the layout of the modifiers. I prefer this order:

Super Alt Ctrl Space Ctrl Alt Super

[ If there is a Menu key, move it to the right corner and consider assigning it to the Compose key if you are on Linux. ]

Now Ctrl is under the thumb, which is especially nice for Emacs. Alt and Super can be swapped, if you use Super more heavily (e.g. with a tiling window manager). But the important part is to keep Ctrl close to the Space key.

Whatever you do though, remember to use both sets of modifiers. For example, C-x involves the right hand for Ctrl and the left hand for x. C-p needs the left hand for Ctrl and the right hand for p. This way you distribute the burden so no one side is overworked (and, of course, you take regular breaks from typing altogether).

Lots of Emacs users will rebind Caps Lock to Ctrl. While this is fine in its own right, it tends to embed bad habits, such as with using only the left hand to register the very common C-a, C-e, C-d, C-f, C-s, C-r, C-w, C-g, C-z, C-x, C-c, C-v. Exclusive left-handed use involves awkward twisting of the muscles which will probably hurt you over time. Plus, the left pinky is forced to press and hold a key while being stretched—looks bad. Again, distribute the load.

The final part that makes everything easier is to configure a “layer” key. When you press and hold this key, other keys register a different input than normal. For example, Caps Lock can be the layer key, which then makes h, j, k, l act as arrow keys. Same idea for mapping Home, PgDn, PgUp, End someplace that makes sense (mine are on y, u, i, o). I prefer to have Space as that layer key: it only is a layer when I press and hold it, otherwise it performs the ordinary function of the Space key.

It is okay to press and hold Space because you do it with your relatively strong thumbs. Better have it this way than pressing and holding with the pinkies.

All this can be achieved with software such as kanata. A custom keyboard with QMK firmware can get the same configuration embedded directly in the keyboard (so it works without any special program running on the computer). Kanata will be the cheaper solution and is probably better overall if you consider that it can apply to a laptop’s keyboard.

A mistake in all this is to think that an expensive keyboard is inherently more ergonomic. If you keep curling, overextending, or anyhow stressing your muscles the injuries will occur regardless. A new keyboard can help if you use it as an opportunity to retrain your muscle memory.

Custom keyboards have potential advantages in terms of comfort because you can change the switches and keycaps that they use. For example, you can pick a lighter or heavier switch to match your typing technique. Then you can combine it with a shallower or steeper keycap profile to get the most out of that setup. There is no right or wrong here. It is a matter of optimising on top of the strong fundamentals that I outlined above.

As for evil-mode in Emacs, I think it is a good solution overall. You do, however, need to install the evil-collection package and probably also configure lots of other key bindings to get exactly what you want. There are other packages that give you modal editing, though I have only ever used evil-mode in earnest: it is fine.

That granted, I find that I do not like modal editing in general. It is especially inconvenient for me when I write at length (which I do a lot) because I tend to produce a wall of text in one go. Having a modal interface gives me no advantage in this common scenario. I also doubt it ever gave me the edge while programming. The bottleneck is how quickly and clearly I can think, not how fast I can edit lines of text (though, yes, Vim’s paradigm is powerful).

Consider then the overall comfort of your setup. Both in terms of the ergonomics of hardware but also how much effort it takes to maintain your Emacs configuration. The standard approach to key bindings gives you something that “just works” with practically every package you install. It may feel awkward in the beginning if you are coming from the Vim keys, but will be the most robust solution long-term from the perspective of maintainability.

I love teaching. I do not love grading, though. I’ve always thought it would be an ideal job if there were no requirement for grades, and if there were no grades, then there would be no need for exams. This, of course, isn’t true. In an ideal world, each student would be motivated to acquire knowledge, wisdom, and understanding, not a mere grade. Good students would still want some kind of assessment, so that they could know if they had reached their desired level of understanding. It seems that I can’t escape the necessity of testing.

I prefer to give essay exams in my upper-level courses, but the larger sizes of introductory courses make that impractical. Multiple-choice questions are easy to grade, but good ones are difficult to write. It would be nice to have a question bank from which I could easily choose questions to include on an exam, all stored in an easy-to-write format that could be used to produce both online and print versions of a test. This sounds like a perfect task for Emacs and Org mode.

Two years ago, I posted my method of writing quizzes in Org mode for import into Canvas, the LMS our university uses. I decided to use this format for multiple choice:

1. Multiple choice question (single correct answer)
   a) Wrong
   b) Wrong
   c) Right*
   d) Wrong

The multiple choice question bank will then consist of a collection of enumerated Org mode lists, something like this:

1. Why is global skepticism especially difficult to rationally respond to?
     a) It requires accepting the existence of the external world before any argument can begin.
     b) It is logically self-contradictory and therefore cannot be engaged directly.
     c) There are no premises the skeptic would grant that could be used against the position.*
     d) It collapses into local skepticism when pressed by careful argument.
2. What is Mackie's central claim in "Evil and Omnipotence"?
     a) The existence of evil makes theism unlikely but not impossible
     b) Religious beliefs about God and evil are positively irrational, not merely unsupported*
     c) Omnipotence is logically incompatible with omniscience
     d) The free will defense successfully resolves the logical problem of evil
3. Why is proving the nonexistence of the evil demon insufficient to establish knowledge of the external world?
     a) The evil demon could simply be replaced by an equally deceptive force.
     b) Disproving active deception still leaves open the possibilities of dreaming and naturally broken senses.*
     c) The evil demon argument applies only to sensory knowledge, not to rational knowledge.
     d) Proving a negative is logically impossible within Descartes' method of doubt.            

I decided to have a frame split into two windows, the question bank in one and the scratch buffer in the other. I’d like to select questions from the bank and have them copied to the scratch buffer. Here’s the function that I wrote with the help of Claude:

(defun rlr/copy-mcq-to-scratch ()
  "Copy the multiple choice question at point to the *scratch* buffer."
  (interactive)
  (save-excursion
    (let* ((question-start
            (progn
              (end-of-line)
              (if (re-search-backward "^[0-9]+\\." nil t)
                  (point)
                (error "No question found at point"))))
           (question-end
            (progn
              (goto-char question-start)
              (forward-line 1)
              (if (re-search-forward "^[0-9]+\\." nil t)
                  (match-beginning 0)
                (point-max))))
           (text (buffer-substring-no-properties question-start question-end)))
      (with-current-buffer (get-buffer-create "*scratch*")
        (goto-char (point-max))
        (insert text)))))

If the point is anywhere in a question or one of its answer options, calling rlr/copy-mcq-to-scratch appends the question to the scratch buffer. I could use a keybinding for this, but I’m not sure I write exams often enough to waste a good keybinding. It’s easy enough to create a quick keyboard macro to select the first question and then press F4 for other questions.

If I want to create a Canvas Quiz, then it’s ready to be converted into a QTI file using the method I wrote about earlier. For print exams, I use the LaTeX examdesign class¹, which requires this format for multiple choice:

\begin{question}
  Multiple choice question
  \choice {Wrong}
  \choice {Wrong}
  \choice[!] {Right}
  \choice {Wrong}
\end{question}

To convert the questions, I select the entire scratch buffer and call this function. It formats the questions properly and inserts a blank line between each of them.

(defun rlr/org-mc-to-latex-questions (beg end)
  "Convert org-mode multiple choice questions in region to LaTeX format. Questions are numbered lines followed by lettered choices (a-z). Correct answers are marked with * after the choice text."
  (interactive "r")
  (let* ((text (buffer-substring-no-properties beg end))
         (lines (split-string text "\n"))
         (result '())
         (in-question nil))
    (dolist (line lines)
      (cond
       ;; Numbered question line: "2. Question text"
       ((string-match "^[[:space:]]*[0-9]+\\.[[:space:]]+\\(.+\\)$" line)
        (when in-question
          (push "  \\end{question}" result)
          (push "" result))
        (push "  \\begin{question}" result)
        (push (format "    %s" (match-string 1 line)) result)
        (setq in-question t))
       ;; Choice line: "  a) Choice text" or "  a) Choice text*"
       ((string-match "^[[:space:]]*[a-z])[[:space:]]+\\(.+?\\)\\(*\\)?[[:space:]]*$" line)
        (let* ((text (match-string 1 line))
               (correct (match-string 2 line))
               (tag (if correct "\\choice[!]" "\\choice")))
          (push (format "    %s {%s}" tag text) result)))))
    (when in-question
      (push "  \\end{question}" result))
    (let ((output (mapconcat #'identity (nreverse result) "\n")))
      (goto-char beg)
      (delete-region beg end)
      (insert output))))

The next tasks are functions for easily removing and reordering questions. For that, I should probably wait until finals are over, though.

Now, unfortunately, it’s back to grading.

EDIT (May 4, 2026):

I must not be able to think when it’s later in the day. Reordering the questions is easy. Since they’re just Org lists, M-up and M-down moves an item and its child lists up and down. Deleting questions is not quite as easy, but it still wasn’t difficult:

(defun rlr/delete-mcq-at-point ()
  "Delete the multiple choice question at point, including all its choices."
  (interactive)
  (save-excursion
    (beginning-of-line)
    ;; If on a choice line, move up to the question line first
    (unless (looking-at "[[:space:]]*[0-9]+\\.")
          (re-search-backward "^[[:space:]]*[0-9]+\\." nil t))
    (let ((start (line-beginning-position))
              (end (progn
                       (forward-line 1)
                       (if (re-search-forward "^[[:space:]]*[0-9]+\\." nil t)
                           (match-beginning 0)
                         (point-max)))))
          (kill-region start end)))
  (org-list-repair))

I used kill-region to save the question to the kill ring, followed by org-list-repair to renumber the list. Killing instead of deleting is useful in cases where one might want to move the question farther than would be convenient with a simple reordering.

Protesilaos (Prot) has a new, interesting package available: buffer-to-pdf. It does just what its name suggests. It takes the current Emacs buffer and exports it to PDF preserving things like theme, and font characteristics.

It’s easy to use. You simply call buffer-to-pdf and you get a PDF of your current buffer. You can specify the orientation—portrait, landscape, or current window—for the output but that’s the only choice you have to make.

The most complicated thing about the package is its pagination. If you have an Org file, each headline is a new page. The idea is to turn it the org file into a set of slides. Again, this all happens automatically.

For a simple text file, buffer-to-pdf paginates at screen borders. That seems like a natural thing to do and allows a certain amount of control over where the page breaks occur by adjusting the window size.

Finally, you can specify explicit page breaks by inserting a form feed (^L). Prot’s video doesn’t make clear how the form feeds interact with the window boundary heuristic but, as Prot says, the best way of thinking about buffer-to-pdf is as a screen capture that produces a PDF. It’s a perfect way to share an Emacs buffer with someone else.

If you’re interested in this package, take a look at Prot’s video at the above link. You can check out the package’s Git repository here.

I’ve been looking for (or rather, chasing!) the right note-taking workflow in Emacs for over a decade now. Back in 2013, I wrote about setting up Deft mode with Org-Mode and it was my attempt at bringing that Notational Velocity-style simplicity into Emacs, and I used it for a long time. I genuinely liked Deft, but it’s no longer actively maintained, and the same goes for Zetteldeft which was built on top of it as an alternative successor. Since then, I’ve tried the other major players – org-roam, Denote, and a handful of others. They’re all extremely impressive and comprehensive packages that do more than I could ever ask for, but none of them ever quite stuck for me. I’d set one up and more or less force myself to use it for a few weeks, and then quietly drift back to a loose pile of org files in a directory. And on my darker days, Apple Notes.

The problem was never these packages – it was more me and my typical, simple workflow that I’ve grown so used to over the years. Learning a new tool carried implicit friction points that compounded over time. Org-roam is powerful, but it is opinionated about note creation - every note needs a unique org-id property and lots of frontmatter that I often had to lookup from previous notes to even remember what to include. The whole system, when used correctly, is backed by a SQLite database via emacsql that indexes your nodes and links. That’s a lot of overhead in my candid opinion. If the database gets out of sync or emacsql has compilation issues, you’re debugging infrastructure instead of taking notes. This was another pain point of mine since I often work on multiple machines (work, personal).

On the other hand, simple tooling like ripgrep is plenty fast for searching files, and removing the database removes an entire category of things that can break – especially for newer users who are already navigating the Emacs and org-mode learning curve. Denote is a great package that uses a lot of good, well-thought-out ideas and tooling, but I found it had a higher barrier to entry and is a bit opinionated in favor of note-taking workflows that I just never adopted or used over the years. This isn’t meant to be a knock on org-roam or Denote - it’s all my preference – but I wanted something that fit how I actually work without getting in my way - and something that I knew I would use long term. The note-taking workflow I wanted is something that felt closer to just opening a folder of org files, but with the modern conveniences that tools like Obsidian offers.

So I wrote grove.el.

What it is Link to heading

Grove is an Obsidian-like note-taking mode for Emacs. One keybinding opens a full workspace with a file tree sidebar and your org notes. No external Emacs dependencies, no databases – just org files, a directory, and ripgrep.

The feature set covers the things I actually want and use daily:

• File tree sidebar – expand/collapse directories, indent guides, current file tracking, item counts, and optional nerd font icons
• Quick capture – the first line becomes the title, saved straight to an inbox
• Wikilinks – [[note title]] syntax, click to follow, creates the note if it doesn’t exist
• Backlinks – ripgrep-powered, computed on demand, displayed in a side panel
• Daily notes – jump to today, yesterday, or tomorrow
• Search – full-text search via ripgrep, with optional Consult integration
• Tag search – works with both #hashtag and org :tag: syntax
• Inbox review – triage your untagged notes
• Graph view – Graphviz-powered visualization of how your notes connect

Why I wrote this Link to heading

The honest answer is that I wanted a note-taking system that I’d actually use. Every previous attempt had some piece that didn’t fit my workflow, and over time that friction compounded until I stopped using it entirely.

What I kept coming back to was how simple tools like Obsidian feels. Yes, I know - it’s basically org-mode but with a pretty GUI! But you open a vault, you see your files, you write notes with wikilinks, and the tool stays out of your way. The graph view is a nice addition - nothing new, but something that I knew I wanted to try and recreate in a less complex fashion. The sidebar is useful visually - often times it is very beneficial to focus on a single, solo buffer, but when it comes to note taking, visually seeing the other notes can add extra context without overloading you - enabling you to add categorization and linking with minimal overhead. My intention was to create something that doesn’t prescribe a methodology - you can do Zettelkasten, GTD, or just free-form notes, and Grove doesn’t care. I wanted that same feeling and purpose that I get when I’m in Emacs, where I already spend a good portion of my day.

Grove is intentionally less opinionated than many of the existing note-taking packages in the Emacs ecosystem. There’s no enforced file naming scheme, no required metadata format, no database to maintain. Your notes are org files in a directory. If you stop using Grove tomorrow, your notes are still just org files. I think that matters most in the end - when you stop using a tool, the underlying bits don’t change, including yourself.

At the same time, I wanted it to be batteries included. One of the barriers I’ve seen with Emacs note-taking setups is that getting everything working – the sidebar (especially this!), the linking, the search, the capture workflow - it all requires stitching together multiple packages and a fair amount of configuration. Grove bundles all of that into a single package with sensible defaults. The goal is that a new user can install it, point it at a directory, and have a complete note-taking workspace immediately. Whether you’re new to Emacs or have been using it for many, many years, the setup cost is minimal and investment low.

Installation Link to heading

Grove requires Emacs 29.1+ and ripgrep. Graphviz is optional for the graph view, and Consult is optional for enhanced search.

Grove is currently in review for MELPA. Once it is approved and merged, you’ll be able to install it with:

M-x package-install RET grove RET

Or with use-package:

(use-package grove
  :ensure t
  :custom
  (grove-directory "~/notes"))

In the meantime, you can install it manually by cloning the repo:

git clone https://github.com/jonathanchu/grove.git

(use-package grove
  :load-path "path/to/grove"
  :custom
  (grove-directory "~/notes"))

Usage Link to heading

The entry point is C-c v v to open the Grove workspace, or M-x grove-open. From there, the full keybinding set lives under the C-c v prefix:

grove
├── C-c v v  Open workspace
├── C-c v q  Close workspace
├── C-c v c  Quick capture
├── C-c v f  Find note
├── C-c v s  Search notes
├── C-c v d  Daily note (today)
├── C-c v y  Daily note (yesterday)
├── C-c v t  Daily note (tomorrow)
├── C-c v b  Show backlinks
├── C-c v #  Search by tag
├── C-c v i  Inbox review
├── C-c v l  Insert wikilink
└── C-c v g  Graph view

The file tree sidebar tracks your current file, and you can expand/collapse directories with TAB. Quick capture (C-c v c) opens a buffer where you type your note - the first line becomes the filename and it’s saved directly to your inbox for later triage.

What’s next Link to heading

I have a few things I’d like to explore next – note templates, tag autocomplete, and some refinements to the graph view to make it interactive. These are definitely nice-to-haves, but I would only want more time to think about some of these more thoughtfully as complexity increases with features like interactive graph views. But the core is solid and I’ve been using it daily as my primary note-taking system, which has been the real test.

If you’ve been looking for a note-taking setup in Emacs that doesn’t require much configuration or revamping your notes workflows, give Grove a try! Feedback and contributions are always welcome.

Philip Kaludercic wanted to continue the conversation from YE24: Sacha and Prot Talk Emacs - Newbies/Starter Kits. He's spent a lot of time thinking about this as one of the main contributors to newcomers-presets, so there'll probably be much to cover!

<2026-05-14 Thu 10:30>–<2026-05-14 Thu 10:30> (America/Toronto -0400) = Thu May 14 1030H EDT / 0930H CDT / 0830H MDT / 0730H PDT / 1430H UTC / 1630H CEST / 1730H EEST / 2000H IST / 2230H +08 / 2330H JST

We'll probably talk about:

• Emacs 31 or Emacs 32 directions towards improving the newcomer experience
• How the newcomers presets fits into the bigger picture
• Documentation and guides
• How to get more feedback from newbies (virtual focus group? mailing list? office hours?)
• Informal community resources
• Other things we can do to help

Related links:

• A proposal for a "beginners" (user-option) theme - Philip Kaludercic
• Re: some file-related options to consider for newcomers-presets - Philip Kaludercic
• A newcomer's feedback on newcomer presets - Abdulnafe Toulaimat
• Emacs Configuration Generator

You can e-mail me at sacha@sachachua.com.

Sean Whitton writes to say that the Emacs development team is planning to start the Emac 31 release process next week. That means that they will cut the Emacs 31 branch and start the process of testing and refining it in preparation for the final Emacs 31 release.

I really like how the development time is handling releases lately. They plan on a major release about once a year and in between time issue updates to fix bugs or problems in the latest major release.

If you follow the Emacs Devel mailing list, you’d think that the developers’ full time job is Emacs and that they have no family. It’s incredible how much unpaid time these people devote to Emacs
for the benefit of us all. As I always say, if you find yourself in a bar with any of them, the drinks are on you. These guys really are heroes.

Jan G sent me a two-part comment.

I should have dealt with comments I got to my posts on how I deal with secrets in my work notes, here, and here. Better late than never though, I hope.