Planet Emacslife

Irreal: PSA: Use The Lucid Toolkit

2024-12-25T18:42:02+00:00

It’s Christmas, a day that we at the Irreal Bunker celebrate in large part by being slothful. Therefore, today’s offering is a quickie. On the other hand, since it is Christmas, you can also think of this post as a Christmas gift.

Over at the Emacs subreddit, ArcanistCheshire tells us that building Emacs with the Lucid toolkit resulted in an impressive Emacs speedup. This is seconded by Karthink, someone who has shown he knows what he’s talking about.

Sadly, if you’re a macOS user this gift is not for you. It’s only for users of X-windows and even then there are some restrictions. Take a look at the post for the details.

Even if you are a macOS Emacs user, you can take heart because being an Emacs user is a gift all by itself. Merry Christmas

Protesilaos Stavrou: Emacs: sequence notes with new ‘denote-sequence.el’

2024-12-25T00:00:00+00:00

Today I wrote the initial version of the new optional extension denote-sequence.el, which is part of the denote package (current development version is 3.2.0-dev). It provides commands to create “sequence notes”, i.e. notes that have an inherent structure of parent, child, or sibling. A sequence is expressed numerically, such as 1 being a parent, 1=1 the first child thereof, 1=2 the sibling of 1=1 and child of 1, and so on.

In technical terms, this new extension leverages the optional SIGNATURE file name component, per the Denote file-naming scheme (read the manual, which is the source of truth—I write it for you). denote-sequence.el streamlines the creation of signatures to conform with the aforementioned sequencing (in general, the signature file name component is a free-form field that users can employ in any workflow they want).

The new code is available on the sequence-notes-extension branch: https://github.com/protesilaos/denote/tree/sequence-notes-extension. Depending on when you read this, the branch may no longer exist as the code is merged into main.

Those of you who use Denote for your zettelkasten, please give denote-sequence.el a try. If it covers your use-case, let me know what else you want to see as a feature. If it does not conform with your requirements, please tell me if we can do something to make it work for you.

The commands we provide as of this writing:

denote-sequence, which creates a new sequence note of type parent, sibling, or child.
denote-sequence-new-parent.
denote-sequence-new-sibling.
denote-sequence-new-child.

What is Denote

Denote implements an efficient file-naming scheme that makes it easy to retrieve files by their name. This is done by creating new files (“notes”), or by renaming existing ones. For new files, Denote supports any text format, with Org, Markdown, and plain text being covered out-of-the-box. For renaming files, any file is supported (e.g. I use Denote for all my videos).

As such, Denote is open-ended in terms of workflow. It is not just a note-taking package, let alone one that is limited a specific methodology, such as zettelkasten. Still, Denote can excel in those use-cases, among others.

Package name (GNU ELPA): denote
Official manual: https://protesilaos.com/emacs/denote
Change log: https://protesilaos.com/emacs/denote-changelog
Git repositories:
- GitHub: https://github.com/protesilaos/denote
- GitLab: https://gitlab.com/protesilaos/denote
Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.

Irreal: Why You Want Your Tools To Be Programmable

2024-12-24T17:15:23+00:00

A constant theme here at Irreal is that one of Emacs’ virtues is its programmability. Not the ersatz programmability offered by VS Code or even Vim but real programmability. You can introduce new code or change old code while Emacs is running in a seamless manner.

But why is that so important? Aren’t knobs and check boxes enough? Positron has a nice video that provides the answer. The TL;DR is that, no, knobs and check boxes are not enough. They’re more complex to implement and maintain, they quickly go out of date, and they simply aren’t as flexible. With programmability, the user is in charge and can evolve the action of Emacs as needs change.

Positron makes a good point about Elisp and its supposed slowness. The code you write for Emacs happens, as Positron puts it, at the other end of the keyboard and therefore at human speed. It doesn’t matter if it’s slower than C or whatever. It’s fast enough for human senses. For those jobs that require more powerful computation, Emacs simply subcontracts them out to an external process for faster processing.

As far as I know, only Lisp Machines and their descendants offer this kind of programmability. Today, the only widely used piece of software that can do this is Emacs. To me it seems not so much an advantage as a necessity.

It’s a short video (4 minutes, 35 seconds) so take a look. Positron makes some good points.

TAONAW - Emacs and Org Mode: How I handled projects in Emacs org-mode in 2024

2024-12-24T14:57:28+00:00

I mentioned my projects file, now.org, is getting a little bit out of control. I’ve been playing around with a few ways to organize it since.

This is firstly a conceptional problem, one that has to do with how I organize things mentally before I can go into the technical level of how to tell Emacs to do it: a “what do I want to see?” question before a “how do I do it?” one.

Let me start by showing you what my project file looks like now:

As you can see, a lot is going on.

One of the issues that are already fixed in this image is having the “DONE” or “CANCELLED” projects at the end of the file. This looks more organized than having them mixed with the “ACTIVE” projects all over, and it also allows me to focus on the things I’m currently working on as soon as I open the file.

By default, org-mode adds newly created headers at the bottom of the file. This means that every time I add another project or a meeting (an “ACTIVE” or “MEETING” in the image), it goes to the bottom of the list, right under the last header. I have to fix this manually by standing on the header I just created and moving it up with (M+↑) all the way to the top. However, I recently looked for a solution and found it: adding prepend: t to my capture templates. This reverses the order, so this problem will automatically sort itself out.

In my image, you can also see that some headers start as “Project:” and then the project’s name. This is redundant, and I hope to get rid of this soon because anything that is marked as “ACTIVE” is a project - which is defined by having sub-tasks (marked as “TODO”) under it; the idea is that a project is a large undertaking that has to be broken first to manageable parts:

I write notes under each one of those sub-task headers (as you can see under the first one). I also find it helpful to attach relevant files (in this example, the Reserved IPs header has an Excel sheet containing details). I find that it’s easier to find files through Dired on Emacs than it is looking for them in my work’s OneDrive because they are tied to the project in the right place and arranged by date at the same time by my header’s ID (I changed that from random slugs to date-formatted IDs in the past). I can also jump directly to the directory with those files with C-c C-a F, and then use the open command on macOS (M-x !open) to open it with the default application.

Most of the projects in both images have a percent to completion next to them. Since I usually don’t know what a certain project requires to complete when I start it (what subtasks are required or how many), this is more of a general guide, if anything. Still, I like knowing how much of a project is already done. The percent cookie is an feature built into org-mode¹.

Not in the images yet are emojis. I’m playing with the idea of including a small person emoji (🙋‍♂️) in “MEETING” headers to make them stand out a bit more. Meetings, as it turns out, are a special kind of project. It’s a place where a lot is going on at once, and I mark a “MEETING” as “DONE” only after all the actionable notes are distributed to tasks. Meetings can include tasks that start a whole new project or fit into existing ones. It’s also possible to meet about a certain project, so the “MEETING” header needs to be refiled under an existing project later as one of the subtasks. Meetings can take a long time to break down and follow up on, making them a project in themselves: this is why I found that giving them a dedicated keyword is a good way to handle them².

Another thing I added to the projects' capture template is clocking in as soon they’re created with :clock-in t. I often forget to clock out later, but I want to keep trying and build this as a habit. If I create a clock with a project, Emacs creates a :LOGBOOK: line for me with the time I started working, and I can correct the hours later. This is another area where it’s more of a guide than critical information: it’s often inaccurate (because I forget to clock out and then in again), and also, it doesn’t matter to me if I work half an hour more or half an hour less on something. It’s more of an indication of how much time a certain project took and how often I worked on it during the week.

Projects are also tagged with people I regularly work with. I know some folks (and I get to know many more) personally. When this happens, it’s helpful to see recognizable projects and tasks tagged with names I know. Since tags are hereditary in Emacs, an entire project can be tagged with a person if it’s required, but usually, I need different people for different subtasks of a certain project, depending on what I do. This is helpful to see how much I am working with a certain person, what on, and what that person does. I also have another file for people I work with, along with their names, their ID, their department, and what they do; it’s my useful “I know a guy” file I can tap into when I need someone to do something or when someone else asks me if I know how to handle a certain thing. I then can say, “I don’t, but I can find someone who can for you.” Helpful.

I can add a couple more things here, but this is probably a good place to stop. If you have any questions or suggestions, feel free to comment! I’d love to hear from you.

Footnotes

¹: It’s also worth noting that half of the time, I need to “re-ACTIVE” a project marked as “DONE” because of a new development or because it would happen again and might become more of a routine. This means new “TODO” tasks are added below, and the percentage goes back down from 100%, so, yes, this is more a visual guide than anything concrete.

²: I use at least two (but sometimes more) datestamps in a “MEETING” project. The first time stamp is usually before the meeting takes place: this is where I write down a list of bullet points I want to bring up and discuss. The second timestamp takes place during the meeting (I type while people talk, and I ask them to slow down or wait if I need to (by the way, this is something that worked horribly for me with a notebook: my attempts and my attempts at something that looks like handwriting in meetings while rushing were laughable at best. I missed critical points that way). The second timestamp then becomes an indication to look for actionable items later. Since I write these notes in bullet points, it’s also easy to copy them back into Outlook with minor editing to leave a summary or meeting minutes later.

Protesilaos Stavrou: Emacs: sxhkdrc-mode version 1.1.0

2024-12-24T00:00:00+00:00

This is a major mode for editing sxhkdrc files. SXHKD is the Simple X Hot Key Daemon which is commonly used in minimalist desktop sessions on Xorg (I use it with bspwm, herbstluftwm, and i3wm). The sxhkdrc file configures key chords, binding them to commands. For the technicalities, read the man page sxhkd(1).

Package name (GNU ELPA): sxhkdrc-mode
Git repositories:
- GitHub: https://github.com/protesilaos/sxhkdrc-mode
- GitLab: https://gitlab.com/protesilaos/sxhkdrc-mode
Backronym: Such Xenotropic Hot Keys Demonstrate Robustness and Configurability … mode.

This is a small set of changes to an already stable package.

The Outline of a file is more refined

Each file now has an outline which consists of comment pseudo headings (starting with three or more # followed by a space) and lines with a key binding. Before it was just the comment headings.

Additionally, the heading levels are defined such that key bindings are inside the comment headings when we do the folding. This is what we have in, for example, elisp-mode.

The built-in outline-minor-mode benefits from this change as do third-party commands like consult-outline from the consult package.

For example, we can get outline-minor-mode folding of this:

# Focus in the given direction. With Shift move the client in the
# given direction. With Ctrl resize the frame in the given direction.
mod4 + {_, shift +, ctrl +} {h,j,k,l}
    herbstclient {focus,shift,resize} {left,down,up,right} {_,_,0.05}

To this:

# Focus in the given direction. With Shift move the client in the
# given direction. With Ctrl resize the frame in the given direction.
mod4 + {_, shift +, ctrl +} {h,j,k,l}...

And the same idea for all heading levels.

Syntax highlighting includes the dot in command names

I made it so that when we bind a command to a key, we get its full name highlighted even if that includes a file name extension. So now the herbstluftwm_load_workspace_layout.sh in the following sample will get colourised instead of the name without .sh:

mod4 + w ; {f,t,h,m}
    herbstluftwm_load_workspace_layout.sh {full,third,half,middle}

Another benefit of this refinement is that something like the built-in command mark-sexp will recognise the whole name as a syntactic unit.

Alvaro Ramirez: Hello emacs.tv

2024-12-23T17:39:57+00:00

23 December 2024 Hello emacs.tv

A few days ago, Sacha Chua mentioned how cool it would be to have an Emacs video index like Ruby Video. I mentioned how I had similarly considered a low-tech solution, maybe powered by plain text (bonus points for org mode of course).

A little later, Sacha shared a preliminary video feed dump, in org! With that, I wrote the first experiment to render the org feed and emacs.tv was born.

emacs.tv is merely a few days old. Powered by an org feed (rendered client-side), but we can fetch and render in all sorts of ways. emacs.tv brings it to the web, though I'm sure we can come up with all sorts of Emacs integrations. A new major mode? Or maybe convert the org feed to rss and plug into elfeed?

This is what a feed entry looks like:

* EmacsConf.org: How we use Org Mode and TRAMP to organize and run a multi-track conference :emacsconf:emacsconf2023:org:tramp:
:PROPERTIES:
:DATE: 2023-12-03
:URL: https://emacsconf.org/2023/talks/emacsconf
:MEDIA_URL: https://media.emacsconf.org/2023/emacsconf-2023-emacsconf--emacsconforg-how-we-use-org-mode-and-tramp-to-organize-and-run-a-multitrack-conference--sacha-chua--main.webm
:YOUTUBE_URL: https://www.youtube.com/watch?v=uTregv3rNl0
:TOOBNIX_URL: https://toobnix.org/w/eX2dXG3xMtUHuuBz4fssGT
:TRANSCRIPT_URL: https://media.emacsconf.org/2023/emacsconf-2023-emacsconf--emacsconforg-how-we-use-org-mode-and-tramp-to-organize-and-run-a-multitrack-conference--sacha-chua--main.vtt
:SPEAKERS: Sacha Chua
:SERIES: EmacsConf 2023
:END:

We need your help

As mentioned, this is a new project. It's a good start, but it can only get better with your help.

Submit more content

Sacha kickstarted a wonderful video feed, a collection of 1715 videos as of today. We need more. Are your published videos missing? Reckon other videos should be listed? Please help by submitting new entries.

Improve our tagging

Many of the listed videos could use more tags. Please help us by tagging content in video.org and submit a pull request.

Take it for a spin

Or maybe just take emacs.tv for a spin and give us some feedback.

Happy holidays! 🎄☃️

Irreal: 24 Emacs Packages To Try During The Holidays

2024-12-23T16:15:28+00:00

Marie K. Ekeberg has a holiday gift for Emacs users: a list of 24 Emacs packages that you can try during the holidays. The list is interesting in that it doesn’t really have a theme other than that they’re packages that Ekeberg finds useful or interesting. Some of them are builtin, some of them are in MELPA / Gnu Elpa, and some of them aren’t in any ELPA repository.

Some like Org-mode, Windmove, Magit, EXWM, Multiple cursors, and vterm will be familiar to most Emacs users but some may be new—at least they are to me. The first on the list is Try. Mike Zamansky often used it in his Emacs videos to try out a package without actually installing it. If you want to sample some of the offerings from the list, installing Try first is a good idea because it lets you experiment with a package without having to commit to it.

Another very useful package is undo-tree. It’s a little hard to get used to but it really will improve those times when you have to undo some text. It also rationalizes “redo”. That alone is worth installing it for.

One package that I haven’t tried but that looks interesting is focus. The idea is that text outside some configurable region get grayed out. I’m not sure it would work for me but it does look interesting. It provides a perfect example of why you should install Try: you can experiment with it and if you don’t like what you see, it will disappear the next time you start Emacs.

The list is worth taking a look at You may find something that will fit in with your workflow.

Marcin Borkowski: Watching variable changes

2024-12-23T15:48:57+00:00

Today I have a short Elisp trick, probably slightly more interesting than useful, but still. A long time ago I wrote about some debugging capabilities of Emacs Lisp. The feature mentioned in the last of these posts, debug-on-variable-change, allows to invoke the debugger whenever some Elisp code changes the value of a variable (with a few minor limitations). What I didn’t mention then is that you can actually do things other than start the Emacs debugger when a variable’s value changes.

Sacha Chua: 2024-12-23 Emacs news

2024-12-23T15:27:13+00:00

Help wanted:
- Org Mode requests: [FR] Allow SPC to scroll todo/tag selection menu - for users with huge accessible fonts (was: Transient: accessibility problems for users who need to use large fonts)
Emacs updates:
- Emacs 30.0.93 pretest is available (Reddit, Irreal)
- Emacs 31 News Stream VOD (01:26:53)
Upcoming events (iCal file, Org):
- Emacs Berlin (virtual, in English) https://emacs-berlin.org/ Wed Dec 25 0930 America/Vancouver - 1130 America/Chicago - 1230 America/Toronto - 1730 Etc/GMT - 1830 Europe/Berlin - 2300 Asia/Kolkata – Thu Dec 26 0130 Asia/Singapore
- Emacs APAC (virtual) https://emacs-apac.gitlab.io/ Sat Dec 28 0030 America/Vancouver - 0230 America/Chicago - 0330 America/Toronto - 0830 Etc/GMT - 0930 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore (announcement)
- M-x Research: TBA https://m-x-research.github.io/ Fri Jan 3 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Sat Jan 4 0000 Asia/Singapore
- 🧠💻 Emacs User Meetup - 38C3 (@cabhan@social.tchncs.de)
Emacs configuration:
- How to Share Your Emacs Configuration Between Different Machines (and Architectures) with Native Compilation (Reddit)
Emacs Lisp:
- Bringing Emacs Introspection & Debugging to Casual Suite (Reddit)
- callnum.el; Sort library call numbers (Reddit)
- Kisaragi Hiu: Emacs: turning parsed XML/HTML nodes back into text (encoding/printing/writing it out)
Appearance:
- Change theme by sunrise and sunset with circadian package
- konrad1977/neofusion-emacs: Emacs port for NeoFusion theme from Neovim (Reddit)
- Protesilaos Stavrou: Emacs: two new Standard themes (‘standard-light-tinted’ and ‘standard-dark-tinted’)
Navigation:
- Extending Built-In Emacs Bookmark Package (@takeonrules@dice.camp)
- Rethinking Minibuffer Movement (Reddit)
- Lisp expression replacements with query-regexp-replace (Reddit)
Dired:
- Automatic fallback to /sudo: for local dired commands
Writing:
- Configuration for super-fast Latex input using AucTeX, CDLatex and a bit of YaSnippet. See karthinks.com/software/latex-input-for-impatient-scholars
- Using Howm in Emacs for Notes and Tasks - System Crafters Live! (02:11:21)
Org Mode:
- New Package: org-ranker.el - sort org headlines by custom rules (Reddit)
- Org-supertag v0.0.2 released - enhance tag system of org-mode (Reddit)
- Emacs Org Attach Various Methods 2024_12_17_14:56:08 (04:04)
- DSLiDE v0.6.0 Your slides now play keyboard macros (Reddit)
- Thanos Apollo: Progress update on org-gnosis & a graphical interface addition.
- What is desireable in an Org to HTML framework?
- How to mirror worg to a hyperdrive
- How I use Emacs to publish "food" recipes
Completion:
- Rahul Juliato: Enhancing icomplete-vertical-mode in Emacs (Reddit)
Coding:
- Meta Redux: State of CIDER Survey (2024)
- Tree-sitter Changes in Emacs 30 (Reddit)
- Run JUnit method or class at point (@skybert@hachyderm.io)
- Трошки про Emacs (21:31) - Clojure
- Using uv in Emacs | MClare Blog - python environment
- Xah Talk Show 2024-12-21 Ep605. Run Code of Python JS Fsharp Etc in Emacs. Are You Based? (53:31)
- Bases de Datos-SQLite en GNU Emacs - encuentro/taller - FTV (@hispaemacs@fosstodon.org)
Math:
- Ruslan Bekenev: Emacs: quick-calc
Web:
- TIL eww-copy-alternate-url
- eww-readable + imenu = quickly jump to different headings in webpage (@marcc@fosstodon.org)
- Adding HTML5 Display Block Elements to Emacs’ SHR (and EWW) Tag Rendering // Take on Rules (@takeonrules@dice.camp)
Mail, news, and chat:
- mastodon.el 1.1.8: adds support for link-hint, bugfixes
- glenneth/discourse-emacs: A modern Emacs package for seamless Discourse forum integration. (@barocio@techhub.social)
Multimedia:
- emacs.tv (Hello emacs.tv, 1700+ videos)
- Sacha Chua: subed.el: Tweaking subtitle times
EXWM:
- How to Use Emacs as a Desktop Environment in Linux with EXWM - Make Tech Easier
AI:
- llm version 0.20 released, with structured JSON output
- chatgpt-shell: LaTeX rendering now turned on by default on LLM shell
- lepisma/onnx.el: ONNX runtime for Emacs Lisp (Reddit) - optimized and portable ML on the edge, also interchange format for neural network models
Community:
- Weekly Tips, Tricks, &c. Thread — 2024-12-18 / week 51
- 00: Why You Want Programmable Tools (04:36, Reddit)
- What can we learn from Neovim’s rise in popularity? (HN)
Other:
- James Dyer: Calculate Number Of Days Between Two Dates - calendar-count-days-region
- glotlabs/gdrive: Google Drive CLI Client (@mousebot@todon.nl)
- HTML Renderer (Emacs) - Masonry (Reddit)
- HTML Renderer (Emacs) - colspan (Reddit)
- Marie K. Ekeberg: 24 Emacs packages and utilities to try while counting down to Jul/Christmas/Holidays
- positron-solutions/moc: Master of Ceremonies. Display & presentation utilities to make presentation packages more effective (Video, Reddit)
- The Semantics and Broad Strokes of Buffer Parallelism
- Andrey Listopadov: Extending Emacs with Fennel
Emacs development:
- emacs-devel:
  - Re: Some experience with the igc branch next impediments for IGC branch
  - Merging scratch/no-purespace to remove unexec and purespace - discussion, preparing to merge
  - Re: Merging scratch/no-purespace to remove unexec and purespace - ideas
    - Re: Merging scratch/no-purespace to remove unexec and purespace - hints/guesses vs promises
- * lisp/vc/smerge-mode.el (smerge-extend): New command (bug#74509)
- Add support for the ':data' keyword for play-sound in MS-Windows.
- 'seconds-to-string': new optional arguments for readable strings
- Add more documentation for TTY child frames
- NEWS entry for the removal of `redisplay-dont-pause'
- NEWS entry for tty child frames
- New treesit thing 'sexp-list' (bug#73404)
- Delete support for the Conkeror web browser
- New user option browse-url-transform-alist
- Make font-lock face variables obsolete
- Rename the property 'repeat-continue-only' to 'repeat-continue'
- ; * etc/NEWS: Mention 'eager-display' for 'completion-category-overrides'.
- unintern: Drop support for obsolete calling convention
- all-completions: Drop support for obsolete calling convention
- ; * etc/NEWS: Add 'completion-table-with-metadata' to "Lisp Changes".
- * lisp/comint.el (comint-complete-input-ring): New command (bug#74694).
New packages:
- copilot: An unofficial Copilot plugin (MELPA)
- dicom: DICOM viewer - Digital Imaging & Communications in Medicine (GNU ELPA)
- kill-dollar-mode: Remove leading $ from shell-script-like text (MELPA)
- moc: Master of Ceremonies (MELPA)
- ocaml-eglot: An OCaml companion for Eglot (MELPA)
- p4-ts-mode: Major mode for the P4_16 programming language (MELPA)
- russian-calendar: Russian holidays and conferences. Updated 2024-11-22 (MELPA)
- symbol-overlay-mc: Mark highlighted symbols with multiple cursors (MELPA)
- uv-mode: Integrate uv with python-mode (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Mastodon #emacs, Hacker News, lobste.rs, programming.dev, lemmy.world, lemmy.ml, communick.news, 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!

View org source for this post

Meta Redux: State of CIDER Survey (2024)

2024-12-23T12:48:00+00:00

TL;DR You’ll find the survey here.

It’s been a while since the first and only “State of CIDER” survey.¹ Right after it happened in the end of 2019, the world went to shit and I kind of forgot about my intent to do the survey annually. 5 years later, it’s high time we get back on track!

CIDER has changed a lot in the past 5 years. nREPL has changed a lot. The development tooling Clojure ecosystem has changed a lot. Even Emacs has changed a lot. I’m guessing your usage of CIDER has changed a lot as well. If you’re still using Clojure and CIDER today, that is…

You can find the new survey here. We’ve made several updates to the questions - most notably there’s now a question about how frequently are you using certain CIDER features.

I’ve been thinking a lot lately that perhaps we went overboard with the feature-set in CIDER and that it might be prudent to trim the fat in CIDER 2.0, but we need data, so we can accurately know what’s being used and what’s not. I’ve also been thinking that mentioning many of the less known features in the survey might provoke some people to try them out. We’ll see.

There are other important questions that I like to get answers for, e.g.:

Can we drop support for Emacs 26 (and maybe even Emacs 27)?
Can we drop support for Java 8?²
Do people think that CIDER improved in the last year?
How often are people upgrading their CIDER installation?
What problems are users encountering? What would they like to see added/changed/improved?
Are people willing to support the project in one way or another?³
Is Figwheel still a thing in ClojureScript?

Your responses will also be instrumental in shaping up the roadmap for CIDER 2.0.

Last time around we got 545 responses and I hope this time around we’ll do a bit better, as more responses mean that the data we got is more accurate. The new survey is off to a pretty slow start - less than 200 responses in the first week. It will likely stay open till the end of January, so I hope we are going to get 500+ responses in total this around time as well.

Thanks for taking the time to fill in the survey! This means a lot to me and our team! I’d really appreciate it if you shared the survey on your social media profiles, so more people see it and take part in it. Let’s make CIDER better together!

That’s all I have for you today. Keep hacking!

https://metaredux.com/posts/2019/11/02/state-of-cider.html ↩
Who am I kidding here… I’m well aware we’ll be stuck supporting it for all eternity… ↩
The financial support the project has received eroded quite a lot in the last couple of years, which was somewhat disappointing given all the work that went into CIDER and its ecosystem. ↩

Alex Popescu: easysession.el Emacs Package for Handling Sessions

2024-12-23T12:36:51+00:00

The author uses easysession.el by setting up each session to represent a distinct project or a specific “view” on a particular project, including various tabs (built-in tab-bar), window splits, dired buffers, and file editing buffers. This organization allows for the creation of dedicated environments for different tasks or aspects of a project, such as development, debugging, specific issue, and documentation. The author switches between projects and views of the same projects multiple times a day, and easysession.el helps significantly by allowing quick transitions between them.

Kisaragi Hiu: Emacs: turning parsed XML/HTML nodes back into text (encoding/printing/writing it out)

2024-12-23T07:47:15+00:00

TL;DR you might want shr-dom-print. I wanted to write this down because it's kind of non-obvious. To parse XML / HTML text into nodes, there are libxml-parse-xml-region and libxml-parse-html-region functions which return nodes that can be manipulated with, say, functions from dom.el. But after you got the right parse tree and want to write it out back into a text with XML tags, neither xml.c nor xml.el offer an option for that.

Christian Tietze: Fold Search Results Away in rg.el

2024-12-22T11:11:31+00:00

With the power of outline-minor-mode in Emacs, you can turn any text buffer into an outline – with the killer feature of “cycling”, i.e. folding and unfolding outline elements.

This includes rg.el-managed buffers, search results powered by ripgrep.

Update 2024-06-07: I changed the approach to a more robust regex! The form-feed insertion actually broke result navigation. compilation-next-error in turn would expect not to find a form-feed character at the start of a line. Working around that was more trouble.

To tell rg.el buffers which line is a ‘heading’ in terms of outline-minor-mode, change the regular expression to match each line beginning with "File:":

(defun ct/rg-enable-folding ()
  "Configure outline-minor-mode on file entries in rg.el results."
  (setq-local outline-regexp "^File: ")
  (outline-minor-mode t))
(add-hook 'rg-filter-hook #'ct/rg-enable-folding)
(define-key rg-mode-map (kbd "<tab>") #'outline-cycle)

With that, you can run a search and zoom out to all files via M-x outline-hide-sublevels and then zoom into each with a tab.

Note that even though outline-regexp’s documentation says that we can assume we’re at the beginning of a line etc., omitting the ^ to denote the start of a line produces wonky results: it will fold, but sometimes, it would fold too much. I had file entries further down the buffer be folded away, too, and outline-hide-sublevels would hide the complete buffer.

My Previous Attempt That Is Actually Broken: Inserting a Form Feed

The default outline-regexp value contains the form-feed character. That gave me ideas

I now decorate all "File:" lines, prepending a form-feed character:

;;; Warning: this breaks navigation in result buffers!
(defun ct/rg-add-form-feed ()
  "Prepend a form feed character to all file match lines."
  (save-excursion
    (goto-char (point-max))
    (while (re-search-backward "^File: ")
      (goto-char (match-beginning 0))
      (insert "�\n"))))
;; Do not add the hook to a broken function! :) 
; (add-hook 'rg-filter-hook #'ct/rg-add-form-feed)

You can enter a literal Unicode 0x0C FORM FEED (FF) character in Emacs by typing C-q C-l. I did that. But that doesn’t render well on the blog, so the code uses Unicode escape sequences. (You could also use "\f" I learned later!)

Form-feed lines between results, with the topmost ones folded away

I do render my form-feeds as lines, by the way. Check out form-feed-mode; the code from my init file is:

(use-package form-feed
  :ensure
  :delight
  :config
  (custom-set-variables
   '(form-feed-include-modes '(prog-mode text-mode help-mode compilation-mode org-mode)))
  :init
  (global-form-feed-mode +1))

Hire me for freelance macOS/iOS work and consulting.

Buy my apps.

Receive new posts via email.

whatacold: Getting Started with Cider for Clojure Programming

2024-12-22T09:17:15+00:00

Here is the outline for my cider tutorial on YouTube, covering basic things you need to know to get started with cider, and starting exploring the fun of clojure programming with the REPL-driven programming approach. Jack In to a REPL C-c M-j (cider-jack-in-clj) start a nREPL and jack in. It works in a project or with a sole .clj file. M-x cider-connect-clj run the command and then fill in hostname and port.

Ruslan Bekenev: Emacs: quick-calc

2024-12-22T00:00:00+00:00

You probably have heard about famous emacs M-x calc. I always wanted to become a poweruser of it but never could. My needs are too simple for it, I just want to quickly add/subtract numbers.

Recently I’ve discovered built-in M-x quick-calc which is perfect for what I need. It is already bound to C-x * q.

You can quickly calculate what’s needed and the result is going to be saved to the kill-ring. You can paste the result in place if you want by prefixing the command with C-u.

Emacs has everything :)

Arne Bahlo: My favorite things of 2024

2024-12-22T00:00:00+00:00

Here are my favorite things, digital and physical, of 2024!

Music

I Love You So F***ing Much by Glass Animals: One of my favorite bands, every single album is amazing. and this is no exception.
Clancy by Twenty One Pilots: There’s artists with unique story telling and then there’s Twenty One Pilots. I really like this album.
From Zero by Linkin Park: This sounds like Hybrid Theory reloaded—which is a good thing—and I love that they’re back.
Older (and Wiser): This is the music you want to hear on long train rides through the country side and on long winter evenings.

Books

These links go to my reviews (no spoilers):

Piranesi by Susanna Clarke: One of the best books I’ve ever read.
Project Hail Mary by Andy Weir: Loved the book and told everyone about it after reading it.
The Expanse series by James S. A. Corey: 7 books plus a few novellas. Couldn’t stop reading!
Useful Not True by Derek Sivers: One of the books that change how you think about the world, incredible read.

Apps

Manet: I’ve started buying my music and hosting it myself this year¹, this app makes it a joy to listen to music.
CouchTimes: The best TV show tracker in the App Store, period. It doesn’t have feature bloat and it respects your privacy.
Ghostty: A super fast, new Terminal emulator for the Mac.
Halide: This camera app has been around for a while, but this year they released Process Zero, a mode that applies minimal corrections and makes photos look more like digital camera photos.

Goods

aranet4: There are cheaper options, but a CO₂ monitor for my home office has helped me keep the air at good levels.
heat-it: This tiny tool draws power from your phone to relieve itch & pain from insect bites.
Leatherman 2H Wave+: The only big Leatherman that’s legal to carry in Germany, super versatile and handy to have around.

What were your favorites?

I even wrote a blogpost about it. ↩

Irreal: Emacs 30.0.93

2024-12-21T16:20:27+00:00

Andrea Corallo writes with some good news: Emacs 30.0.93, the third pretest for Emacs 30.1 is now available for download and testing. The developers are hoping that this is the last pretest before the final release procedure begins.

This should serve as a definitive answer to those who keep insisting that Emacs is dead technology. The update cycle is robust and ongoing. Indeed, I would claim that it’s optimal. The project is not releasing updates every month as a new, incomplete project would, but neither is the project moribund. Rather, it makes fairly consistent yearly major updates as well as bug fix releases in between.

If you don’t mind living on the edge, download and test the new pretest. It will help move the release process forward and get us to Emacs 30 sooner. Even if you can’t help test the new release, raise a glass to the developers who work so hard for nothing besides the love of their work that makes all our lives better.

Irreal: Don’t Leave Home Without It

2024-12-20T17:25:27+00:00

This post doesn’t rise to the Red Meat Friday level but it did amuse me. Like all such memes, it captures an essential truth. The “essential truth” here is that Elisp is the glue that you can use to bind together various Emacs functions—including those you write yourself—to enable bespoke functionality specifically tailored to your workflow.

I often see n00bs saying that they don’t know Elisp and that it’s too much of a chore to learn it. I don’t understand that. Elisp is relatively easy to learn, enables you to make the most of Emacs, and also opens the world of Lisp and all its wonders to you. Why wouldn’t you want to learn it?

I sometimes hear that Elisp is currently the most used Lisp. I don’t know if that’s true but I’d certainly have no trouble believing it. In addition to enabling custom Emacs functionality, I often use it for one-off calculations because it’s easy, Lisp, and built into my editor. More and more, I use Elisp as my go to language for one-offs.

If you’re an Emacs user and don’t already know Elisp, I urge you to consider learning it. It will pay you dividends.

Andrey Listopadov: Extending Emacs with Fennel

2024-12-20T00:23:00+00:00

After watching this year’s EmacsConf and seeing Guile Emacs being resurrected I thought to myself - why limit ourselves to Guile? Sure, Guile isn’t just a Scheme implementation, thanks to its compiler-tower-based design. Other languages exist for Guile VM, such as Emacs Lisp, and Guile manual lists the following languages with various stages of completeness:

ECMAScript
Brainfuck
Lua
Ruby
Python

Sure, it would be nice, if Emacs could natively run all of these, but we have to understand, that Guile Lua is not PUC Lua. Even LuaJIT has difficulties maintaining full compatibility with modern releases of Lua, having us stuck in the realm somewhere between Lua 5.1 and 5.2, while PUC Lua is already 5.4. Future releases would bring more differences, making PUC Lua and Luajit diverge even more.

And Lua is a simple language, unlike something like JS, Ruby, or Python. So I wouldn’t bet on the fact that Guile Ruby would be exactly the same as Ruby. Maybe it will, but it’ll probably take years.

So I thought, why not just use Lua as is? The only thing we can’t do is to run Fennel functions from Emacs Lisp. There were attempts at bringing Lua VM into Emacs, running in the same process, however, as I know, it isn’t stable enough.

However, Emacs can connect to a Fennel REPL, like it does for many other languages, such as Common Lisp or Clojure. Sure, the language is running in a separate process, and this comes with a lot of nuances, but it’s still a possible route.

So I made a small package: require-fennel.el. It’s capable of loading Fennel (or Lua) modules, and defining a set of functions on the Emacs side for every Fennel function in the module.

Running Fennel from Emacs Lisp

For example, we can load Fennel itself into Emacs like this:

(require-fennel fennel)

Now we have all sorts of functions available, for example, here’s fennel.eval:

(fennel.eval "(fcollect [i 1 10] (* i i))")
;; => [1 4 9 16 25 36 49 64 81 100]

Or, we can create a file greet.fnl:

(fn greet [name]
  "Greets NAME with a message."
  (print (.. "Hello, " name " from Fennel!")))

and load it:

(require-fennel greet)

(greet "Andrey")
(require-fennel foo)
(require-fennel vec-add)

Code Snippet 1: "Hello, Andrey from Fennel!" will be displayed in the echo area of Emacs

Let’s ask Emacs to describe the greet function:

greet is a interpreted-function.

(greet NAME)

Greets NAME with a message.

As can be seen, Emacs can show us the function signature and its documentation string obtained from Fennel.

Unlike Emacs Lisp, Fennel functions support destructuring with special syntax based on how data literals are written in Fennel. For example, let’s create a function that accepts a map, and destructures its keys:

(fn foo [{:x x :y y}]
  "Accepts a map with the X and Y keys, and adds them together."
  (+ x y))

After loading it in Emacs we’ll see the following documentation:

foo is a interpreted-function.

(foo ((:y . y) (:x . x)))

Accepts a map with the X and Y keys, and adds them together.

I took some creative liberties and made it so Fennel hash tables are represented as association lists in Emacs Lisp. So the ((:x . 1) (:y . 2)) in Elisp is equal to {:x 1 :y 2} in Fennel. The argument list on the Emacs Lisp side is a bit unconventional, but I think that’s OK.

The same goes for vector destructuring:

(fn vec-add [[x0 y0] [x1 y1]]
  "Adds two 2D vectors."
  [(+ x0 x1) (+ y0 y1)])

Emacs’ documentation uses lists:

vec-add is a interpreted-function.

(vec-add (X0 y0) (X1 y1))

Adds two 2D vectors.

I couldn’t make it work with vectors for some reason, and as can be seen, Emacs tries to upcase parameters, but it doesn’t recognize that y0 is also a parameter. Probably fine, as such documentation would never be generated for Emacs Lisp functions.

We can call such a function with both vectors and lists:

(vec-add [1 2] [1 2])   ;=> [2 4]
(vec-add '(1 2) '(1 2)) ;=> [2 4]

That’s because Fennel doesn’t have a list datatype, it only has associative and sequential tables. Thus I’m using Elisp vectors as the result type.

Data conversion

Here’s how conversion table when passing data from Elisp to Fennel:

Elisp	Fennel
`[1 2 3]`	`[1 2 3]`
`(1 2 3)`	`[1 2 3]`
`((:foo . 1) (:bar . 2))`	`{:foo 1 :bar 2}`
`#s(hash-table test equal data ("foo" 1 "bar" 2))`	`{:foo 1 :bar 2}`
`:foo`	`"foo"`
`'false`	`false`
`"foo"`	`"foo"`

And here’s the conversion table when receiving data from Fennel in Emacs:

Fennel	Elisp
`[1 2 3]`	`[1 2 3]`
`{:foo 1 :bar 2}`	`((:foo . 1) (:bar . 2))`
`(values 1 2 3)`	`(1 2 3)`
`(fn [])`	`(lambda (&rest args) ...)`
`userdata`	`#<udata: 0x55b66bd6ac28>`
`true`	`t`
`nil`, `false`	`nil`

A small note about hash tables and multiple value returns. As can be seen, both are returned as lists. I specifically chose the cons notation for association lists, i.e. (a . b) because this way we can tell apart hash tables and mustivalues. There are no cons cells in Fennel, so no other data structure will be represented like that.

Because multiple values are returned as lists, we have to call apply, if we wish to compose two Fennel functions. In other words, in Fennel we can do this:

(fn rest [_ ...] ...)

(fn first [x _] x)

(first (rest 1 2 3)) ;=> 2

{: first : rest}

Code Snippet 2: fr.fnl

In Elisp, however, we would have to do:

(require-fennel fr)

(apply #'fr.first (fr.rest 1 2 3)) ;=> 2

If we were to call it as (fr.first (fr.rest 1 2 3)) the result would be [2 3], because fr.rest returned a list of return values, and lists are converted to vectors or hash maps depending on their structure.

That’s the basic gist of this package.

More examples

After implementing it I was like a kid in a toy store. With a childish grin, I started loading all my crazy Fennel libraries that I made over the years.

For example, here’s cljlib:

(require-fennel cljlib)

(cljlib.conj [1] 2) ;=> [1 2]

Or, here’s a JSON parser I made:

(require fennel json)

(json.decode "{\"foo\": [1, 2, 3]}")
;; (("foo" . [1 2 3]))

(json.encode '(("foo" . [1 2 3])))
;; "{\"foo\": [1, 2, 3]}"

Here’s a crazy one - I’m loading my Fennel port of a Clojure library clj-http into Emacs, and calling it from Elisp:

(require-fennel io.gitlab.andreyorst.fnl-http)
(require-fennel io.gitlab.andreyorst.fnl-http.client :as client) ; nested module

(client.get "http://httpbin.org/get" '((:as . :json)))

;; => (("headers" . (("Content-Length" . "198")
;;                   ("Access-Control-Allow-Credentials" . t)
;;                   ("Access-Control-Allow-Origin" . "*")
;;                   ("Content-Type" . "application/json")
;;                   ("Connection" . "keep-alive")
;;                   ("Server" . "gunicorn/19.9.0")
;;                   ("Date" . "Mon, 16 Dec 2024 22:56:35 GMT")))
;;     ("reason-phrase" . "OK")
;;     ("length" . 198)
;;     ("protocol-version" . (("name" . "HTTP")
;;                            ("minor" . 1)
;;                            ("major" . 1)))
;;     ("request-time" . 214)
;;     ("trace-redirects" . [])
;;     ("status" . 200)
;;     ("body" . (("args" . [])
;;                ("headers" . (("Host" . "httpbin.org")
;;                              ("X-Amzn-Trace-Id" . "Root=1-6760b023-39ca8e413573df5d14d09486")))
;;                ("url" . "http://httpbin.org/get"))))

Code Snippet 3: I've formatted nested alists to use dot notation for better reading clarity. In other words changed (a (b . c) (d . e)) into (a . ((b . c) (d . e))) which are the same thing.

The client made an HTTP request from the Fennel side and passed the response back to Emacs. The response body was in JSON, but specifying ((:as . :json)) as options map forced parsing the response body into Fennel tables. Which, upon arriving in Emacs Lisp were converted into association lists.

So now we can call Fennel from Elisp. But why stop there? Let’s call Emacs Lisp from Fennel!

Running ELisp from Fennel?..

Since this package uses the Fennel Proto REPL, which is a custom protocol that can be extended at runtime, we can create a set of functions that will allow us to call back to Elisp. Here’s how we extend the protocol:

(let [format-elisp _G.___repl___.pp]
  (protocol.env-set!
   :emacs {:call (->> {:__index
                       (fn [_ k]
                         (fn [...]
                           (protocol.message
                            [[:id {:sym protocol.id}]
                             [:op {:string :require-fennel/call}]
                             [:fun {:sym k}]
                             [:arguments {:list (fcollect [n 1 (select "#" ...)]
                                                  (format-elisp (pick-values 1 (select n ...))))}]])
                           (. (protocol.receive) :data)))}
                      (setmetatable {}))
           :var (->> {:__index
                      (fn [_ k]
                        (protocol.message [[:id {:sym protocol.id}]
                                           [:op {:string :require-fennel/var}]
                                           [:var {:sym k}]])
                        (. (protocol.receive) :data))}
                     (setmetatable {}))
           :eval (fn [expr]
                   (protocol.message [[:id {:sym protocol.id}]
                                      [:op {:string :require-fennel/eval}]
                                      [:expr {:sym expr}]])
                   (. (protocol.receive) :data))})
  {:id 1000 :nop ""})

I had to update the protocol core a bit, adding the protocol.env-set! and protocol.receive functions. The env-set! allows us to create user-visible definitions. So we add the emacs table that holds three fields.

The call field is a table with some metatable trickery. Since it’s an empty table, any key would trigger the __index metamethod. This metamethod can be another table or a function - in our case, it is the latter. This function returns a handler that calls into protocol.message that sends a custom OP require-fennel/call that we can handle in our package.

The same goes for the var field, except it doesn’t return a function, it just returns a value.

The last field, eval, is a combination of both, kinda. It is a function, not a table, and it accepts one argument - an expression to evaluate in Emacs.

However, we can’t use these just yet. The second part of the trick comes from the new ability to extend the main protocol handler with custom handlers:

(cl-defgeneric fennel-proto-repl-handle-custom-op (_op _message _callbacks)
  "Handler for a custom protocol OP.
The first argument OP is used for dispatching.  Accepts the whole
MESSAGE, and its CALLBACKS.  The default implementation of unknown OP is
a nop."
  nil)

With this generic function, we can define new handlers in separate packages. These are the methods I’ve added in require-fennel.el:

(cl-defmethod fennel-proto-repl-handle-custom-op ((op (eql :require-fennel/call)) message callbacks)
  "Custom handler for the require-fennel/call OP.
Accepts a MESSAGE and its CALLBACKS.
The MESSAGE contains a function to evaluate and its arguments."
  (fennel-proto-repl-send-message
   nil
   (format "{:id %s :data %s}"
           (plist-get message :id)
           (apply (plist-get message :fun) (plist-get message :arguments)))
   nil))

(cl-defmethod fennel-proto-repl-handle-custom-op ((op (eql :require-fennel/var)) message callbacks)
  "Custom handler for the require-fennel/var OP.
Accepts a MESSAGE and its CALLBACKS.
The MESSAGE contains a var which value is then returned to Fennel."
  (fennel-proto-repl-send-message
   nil
   (format "{:id %s :data %s}"
           (plist-get message :id)
           (require-fennel--elisp-to-fennel (eval (plist-get message :var))))
   nil))

(cl-defmethod fennel-proto-repl-handle-custom-op ((op (eql :require-fennel/eval)) message callbacks)
  "Custom handler for the require-fennel/var OP.
Accepts a MESSAGE and its CALLBACKS.
The MESSAGE contains an expression which is evaluated and its result is returned to Fennel."
  (fennel-proto-repl-send-message
   nil
   (format "{:id %s :data %s}"
           (plist-get message :id)
           (require-fennel--elisp-to-fennel (eval (plist-get message :expr))))
   nil))

These three fields and methods allow us to do anything with Emacs, and it happens in the same process, so we can access the full Emacs state. For example:

;; Welcome to Fennel Proto REPL 0.6.0
;; Fennel version: 1.5.1-dev
;; Lua version: PUC Lua 5.4
>> (emacs.call.emacs-uptime)
"19 minutes, 17 seconds"
>> emacs.var.emacs-version
"31.0.50"
>> (emacs.eval "(with-current-buffer \" *fennel-elisp*\" (buffer-substring-no-properties (point-min) (point-max)))")
";; Welcome to Fennel Proto REPL 0.6.0
;; Fennel version: 1.5.1-dev
;; Lua version: PUC Lua 5.4
>> (emacs.call.emacs-uptime)
\"19 minutes, 17 seconds\"
>> emacs.var.emacs-version
\"31.0.50\"
>> (emacs.eval \"(with-current-buffer \\\" *fennel-elisp*\\\" (buffer-substring-no-properties (point-min) (point-max)))\")
>> "
>>

Crazy!

Fennelmacs

So now we can write Fennel scripts that can obtain data from Emacs, process it, and pass back the results. Thus, our goal is achieved - we’ve added a second language to Emacs!

Of course, it’s not the same as what Guile Emacs does. We’re still running code in a separate process, adding communication between the two via some protocol. It’s a neat trick, nothing more. Guile Emacs, if it ever becomes the thing, will be more powerful, as we would be able to leverage all these different languages in the same process, possibly sharing the memory, calling functions interchangeably, etc. Some may even write Emacs packages in Brainfuck, who knows.

Still, this is really cool, in my opinion, and shows the power of Emacs pretty well. If you’re into Fennel, like me, I hope you’ll enjoy using this package as I enjoyed making it. See you at Fennel Conf!

Comment via email

Org Mode requests: [FR] Allow SPC to scroll todo/tag selection menu - for users with huge accessible fonts (was: Transient: accessibility problems for users who need to use large fonts (was: [RFC] The best way to choose an "action" at point: context-menu-mode, transient, which-key or embark? (was: Fwd: Org-cite: Replace basic follow-processor with transient menu?)))

2024-12-19T18:04:52+00:00

[FR] Allow SPC to scroll todo/tag selection menu - for users with huge accessible fonts (was: Transient: accessibility problems for users who need to use large fonts (was: [RFC] The best way to choose an "action" at point: context-menu-mode, transient, which-key or embark? (was: Fwd: Org-cite: Replace basic follow-processor with transient menu?)))

Irreal: A Bit More On Guile Emacs

2024-12-19T16:26:23+00:00

A week ago, I wrote about the recent restoration of the Guile Emacs project. Despite my enthusiasm for the original project, I just couldn’t get excited about its resurrection. You can take a look at that post for my reasons why.

To be clear, I believe that if Emacs were being written today, Guile would be the natural choice and a great one. But that ship has long since sailed. Emacs is 40 years old and there are plenty of technical and political reasons arguing against trying to retrofit it now.

Still, it’s an interesting project. If you’d like to know about more about it, LWN has a nice summary of the project and the talk that its leader, Robin Templeton, gave at this year’s EmacsConf. The article lays out the rationale for the project as well as some of the problems—technical and political that it’s apt to encounter.The project is actually pretty far along but there are still performance and other problems to resolve. There’s also the issue of whether the basically conservative user base would accept such a change. As hard as it is to believe, not everyone is as fond as Scheme as some of us and others just hate change, especially in something as essential as their editor.

Sacha Chua: subed.el: Tweaking subtitle times

2024-12-19T14:51:17+00:00

When subtitle times are too far off from the video or audio, people start worrying if their video has frozen or jumped ahead. It's good to keep subtitles roughly in time with the audio.

For EmacsConf, we can get timing information from two places. WhisperX produces a JSON file with word data in the process of doing the speech recognition, and the aeneas forced alignment tool can use synthesized text-to-speech to figure out the timestamps for each line of text compared to a media file.

Aeneas timestamps are more helpful once we start editing, but it can be confused by long silences, extraneous noises, multiple speakers, and inaccurate transcripts (words added or removed).

When I combine the WhisperX word data with subtitles, I can see where the times might need a closer look because matching words weren't found.

Figure 1: Screenshot with word data loaded

Loading word data requires a pretty close match at the moment, but since we change only about 4% of the subtitle text when editing, those cues are still helpful. (I measured this by the Levenshtein distance between the combined cue texts of edited subtitles versus the original WhisperX transcripts, using string-distance to approximate the editing percentage.)

Calculating how much we edited

(let ((sum-original 0)
      (sum-dist 0))
  (append
   (seq-keep
    (lambda (talk)
      (when (and (emacsconf-talk-file talk "--main.vtt")
                 (emacsconf-talk-file talk "--reencoded.json"))
        (let* ((json-object-type 'alist)
               (json-array-type 'list)
               (edited-text
                (mapconcat (lambda (sub) (elt sub 3))
                           (subed-parse-file (emacsconf-talk-file talk "--main.vtt"))
                           " "))
               (original-text
                (mapconcat
                 (lambda (word)
                   (assoc-default 'word word))
                 (assoc-default
                  'word_segments
                  (json-read-file (emacsconf-talk-file talk "--reencoded.json")))
                 " "))
               (dist (string-distance original-text edited-text)))
          (setq sum-original (+ sum-original (length original-text)))
          (setq sum-dist (+ sum-dist dist))
          (list
           (length original-text)
           (length edited-text)
           dist))))
    (emacsconf-get-talk-info))
   '(hline)
   (list
    (list
     sum-original
     (format "%d%%" (/ (* 100.0 sum-dist) sum-original))
     sum-dist))))

To make it easier to correct subtitle timing, I added a few ways to tweak subtitle timing for a region of subtitles.

WhisperX: subed-word-data-fix-subtitle-timing in subed-word-data.el tries to match the word data from WhisperX against the text of the current subtitle, using string-distance for approximate matches. I start at about two words shorter than what's in the subtitle, and then increase the number of words taken from the data while the string distance decreases. I skip the data for words before the beginning of the first subtitle in the region.

Download the video

Screencast of subed-word-data-fix-subtitle-timing

Aeneas: subed-align-region uses Aeneas to realign the subtitles from the region using the section of the media file between the start of the first subtitle and the end of the last subtitle in the region. When I notice that the times are off, I skim the subtitles (or just skim them visually) to find the last well-timed subtitle. Then I pick a subtitle that's in the incorrectly-timed section. I use subed-mpv-jump-to-current-subtitle (M-j) to jump to that position, and I play back that subtitle. It usually belongs to some text further down, so I reset to that position with M-j, set my mark before the previous correctly-timed subtitle with C-SPC, go to the subtitle that matches that time, and use subed-copy-player-pos-to-start-time (C-c [) to set the proper timestamp. Then I can go to the previous incorrectly-timed subtitle and use M-x subed-align-region. This runs the Aeneas forced alignment tool using just the subtitle text in the region, the starting timestamp of the first subtitle, and the ending timestamp of the last subtitle, making it easy to adjust that section. subed-align-region is in subed-align.el

Retiming by pressing SPC after each subtitle: As an experiment, I've also added a subed-retime-subtitles command that plays through the subtitles so that I can press SPC when the next subtitle starts. It begins with the current subtitle and stops when you press a key that's not in its keymap.

Download the video

Screencast with audio: subed-retime-subtitles

Manual adjustments: For fine-tuning timestamps, I usually turn on subed-waveform-show-all and shift-left-click (subed-waveform-set-start-and-copy-to-previous) or shift-right-click (subed-waveform-set-stop-and-copy-to-next) on the waveforms because it's easy to see where the words and pauses are. When I'm not sure, I can use middle-click (subed-waveform-play-sample) to play part of the file without changing the subtitle start/stop or the MPV playback position.

Download the video

Screencast with audio of using the waveforms

I'm experimenting with adding repeating keybindings. There was a subed-mpv-frame-step-map that was bound to C-c C-f, so I've renamed it to subed-mpv-control, added a whole bunch of keybindings to the subed-mpv-control-map based on MPV and Aegisub shortcuts, and made it a repeating transient map.

Download the video

Screencast with audio, experimenting with the mpv control map

Ideas for next steps:

Gotta get the hang of all these new capabilities through practice! =)

To make my subed-align-region workflow even more convenient, I could use completing-read to let me select a future subtitle with completion, and then Emacs could automatically fix the subtitle start time, go to the previous subtitle, and realign the region.

Also, I think switching the waveforms from overlays to text properties could be a good idea. When I cut text, the overlays get left behind, but I want the waveforms to go away too.

While writing this post and fiddling with subed, I ended up adding a bunch of keybindings and a menu. I figured this was as good a time as any to stop tweaking it and finally publish. (But it's fun! Just one more idea…)

View org source for this post

Rahul Juliato: Enhancing icomplete-vertical-mode in Emacs

2024-12-19T14:00:00+00:00

icomplete-vertical-mode is a popular built-in option for Emacs users who prefer a vertical display of completions, offering a more modern feel similar to packages like Vertico or Ivy. Beyond its default use, it can also handle in-buffer completions. However, its behavior in this context may feel counterintuitive if you're not familiar with it or if you're accustomed to more modern in-buffer completion systems like Company, Corfu, or Auto-Complete.

In this post, I’d like to revisit a discussion I initiated back in April 2024, which led to a quick patch you can apply to make icomplete-vertical work more seamlessly for in-buffer completions, bringing it closer to the style of company or corfu.

The issue

Specifically regarding in buffer behaviour of icomplete, let's explore some variations.

Let's supose this minimal config:

(use-package icomplete
  :bind (:map icomplete-minibuffer-map
              ("C-n" . icomplete-forward-completions)
              ("C-p" . icomplete-backward-completions)
              ("C-v" . icomplete-vertical-toggle)
              ("RET" . icomplete-force-complete-and-exit))
  :hook
  (after-init . (lambda ()
                  (fido-mode -1)
                  (icomplete-mode 1)
                  ;; (icomplete-vertical-mode 1)
                  ))
  :config
  (setq tab-always-indent 'complete)  ;; Starts completion with TAB
  (setq icomplete-delay-completions-threshold 0)
  (setq icomplete-compute-delay 0)
  (setq icomplete-show-matches-on-no-input t)
  (setq icomplete-hide-common-prefix nil)
  (setq icomplete-prospects-height 10)
  (setq icomplete-separator " . ")
  (setq icomplete-with-completion-tables t)
  (setq icomplete-in-buffer t)
  (setq icomplete-max-delay-chars 0)
  (setq icomplete-scroll t)
  (advice-add 'completion-at-point
              :after #'minibuffer-hide-completions))

In this example I'll be searching for completions to (setq... and hit TAB for completion.

With icomplete-mode the beginning of the line:

With icomplete-mode on some advanced column:

Now lets toggle comments in our configuration:

;; (icomplete-mode 1)
(icomplete-vertical-mode 1)

With icomplete-vertical-mode the beginning of the line:

With icomplete-vertical-mode on some advanced column:

As you can see, the icomplete-vertical-mode completion won't respect the cursor position, as it happens with its classic horizontal counterpart. It always starts at the beginning of the next line.

A Proposed Solution

Messaging the Emacs help mail list here, quickly got me some answers to this issue.

Zhengyi Fu suggested a patch to address this issue. The patch modifies icomplete.el to prepend spaces to the completion lines, aligning them with the cursor’s column. Here’s the patch:

Index: emacs/lisp/icomplete.el
===================================================================
--- emacs.orig/lisp/icomplete.el
+++ emacs/lisp/icomplete.el
@@ -913,6 +913,16 @@ icomplete--render-vertical
                 ((> (length scroll-above) (length scroll-below)) nsections)
                 (t (min (ceiling nsections 2) (length scroll-above))))
           lines))
+    (when icomplete--in-region-buffer
+      (let ((column
+            (with-current-buffer icomplete--in-region-buffer
+              (save-excursion
+                (goto-char (car completion-in-region--data))
+                (current-column)))))
+       (dolist (l lines)
+         (add-text-properties
+           0 1 `(display ,(concat (make-string column ?\s) (substring l 0 1)))
+           l))))
     ;; At long last, render final string return value.  This may still
     ;; kick out lines at the end.
     (concat " \n"

As noted by Eli Zaretskii, contrary to initial impressions, applying this patch does not require rebuilding Emacs from source. Instead:

• Locate icomplete.el in your Emacs installation.

• Apply the patch.

• Byte-compile the updated file using M-x byte-compile-file.

• Restart Emacs to load the updated behavior.

And as magic, we get:

Another example in a buffer that provides completions with eglot (Typescript LSP Server):

A hacky copy/paste & try it

Of course you can just go hacky and override this function with the applied patch, it is ugly, it is not recommended to do, but if you'd like to quickly try this behavior you could.

Here's a version that may work with Emacs 30.0.92, shh try it and delete, don't tell anyone ;)

(use-package icomplete
  :bind (:map icomplete-minibuffer-map
              ("C-n" . icomplete-forward-completions)
              ("C-p" . icomplete-backward-completions)
              ("C-v" . icomplete-vertical-toggle)
              ("RET" . icomplete-force-complete-and-exit))
  :hook
  (after-init . (lambda ()
                  (fido-mode -1)
                  ;; (icomplete-mode 1)
                  (icomplete-vertical-mode 1)
                  ))
  :config
  (setq tab-always-indent 'complete)  ;; Starts completion with TAB
  (setq icomplete-delay-completions-threshold 0)
  (setq icomplete-compute-delay 0)
  (setq icomplete-show-matches-on-no-input t)
  (setq icomplete-hide-common-prefix nil)
  (setq icomplete-prospects-height 10)
  (setq icomplete-separator " . ")
  (setq icomplete-with-completion-tables t)
  (setq icomplete-in-buffer t)
  (setq icomplete-max-delay-chars 0)
  (setq icomplete-scroll t)
  (advice-add 'completion-at-point
              :after #'minibuffer-hide-completions)

  ;; FIXME - this is actually an override of internal icomplete to provide
  ;;         in buffer on column completion
  ;;
  ;; As first suggested by Zhengyi Fu:
  ;; https://mail.gnu.org/archive/html/help-gnu-emacs/2024-04/msg00126.html
  ;;
  (cl-defun icomplete--render-vertical
      (comps md &aux scroll-above scroll-below
             (total-space ; number of mini-window lines available
              (1- (min
                   icomplete-prospects-height
                   (truncate (max-mini-window-lines) 1)))))
    ;; Welcome to loopapalooza!
    ;;
    ;; First, be mindful of `icomplete-scroll' and manual scrolls.  If
    ;; `icomplete--scrolled-completions' and `icomplete--scrolled-past'
    ;; are:
    ;;
    ;; - both nil, there is no manual scroll;
    ;; - both non-nil, there is a healthy manual scroll that doesn't need
    ;;   to be readjusted (user just moved around the minibuffer, for
    ;;   example)l
    ;; - non-nil and nil, respectively, a refiltering took place and we
    ;;   may need to readjust them to the new filtered `comps'.
    (when (and icomplete-scroll
               icomplete--scrolled-completions
               (null icomplete--scrolled-past))
      (cl-loop with preds
               for (comp . rest) on comps
               when (equal comp (car icomplete--scrolled-completions))
               do
               (setq icomplete--scrolled-past preds
                     comps (cons comp rest))
               (completion--cache-all-sorted-completions
                (icomplete--field-beg)
                (icomplete--field-end)
                comps)
               and return nil
               do (push comp preds)
               finally (setq icomplete--scrolled-completions nil)))
    ;; Then, in this pretty ugly loop, collect completions to display
    ;; above and below the selected one, considering scrolling
    ;; positions.
    (cl-loop with preds = icomplete--scrolled-past
             with succs = (cdr comps)
             with space-above = (- total-space
                                   1
                                   (cl-loop for (_ . r) on comps
                                            repeat (truncate total-space 2)
                                            while (listp r)
                                            count 1))
             repeat total-space
             for neighbor = nil
             if (and preds (> space-above 0)) do
             (push (setq neighbor (pop preds)) scroll-above)
             (cl-decf space-above)
             else if (consp succs) collect
             (setq neighbor (pop succs)) into scroll-below-aux
             while neighbor
             finally (setq scroll-below scroll-below-aux))
    ;; Halfway there...
    (let* ((selected (propertize (car comps) 'icomplete-selected t))
           (chosen (append scroll-above (list selected) scroll-below))
           (tuples (icomplete--augment md chosen))
           max-prefix-len max-comp-len lines nsections)
      (add-face-text-property 0 (length selected)
                              'icomplete-selected-match 'append selected)
      ;; Figure out parameters for horizontal spacing
      (cl-loop
       for (comp prefix) in tuples
       maximizing (length prefix) into max-prefix-len-aux
       maximizing (length comp) into max-comp-len-aux
       finally (setq max-prefix-len max-prefix-len-aux
                     max-comp-len max-comp-len-aux))
      ;; Serialize completions and section titles into a list
      ;; of lines to render
      (cl-loop
       for (comp prefix suffix section) in tuples
       when section
       collect (propertize section 'face 'icomplete-section) into lines-aux
       and count 1 into nsections-aux
       when (get-text-property 0 'icomplete-selected comp)
       do (add-face-text-property 0 (length comp)
                                  'icomplete-selected-match 'append comp)
       collect (concat prefix
                       (make-string (- max-prefix-len (length prefix)) ? )
                       (completion-lazy-hilit comp)
                       (make-string (- max-comp-len (length comp)) ? )
                       suffix)
       into lines-aux
       finally (setq lines lines-aux
                     nsections nsections-aux))
      ;; Kick out some lines from the beginning due to extra sections.
      ;; This hopes to keep the selected entry more or less in the
      ;; middle of the dropdown-like widget when `icomplete-scroll' is
      ;; t.  Funky, but at least I didn't use `cl-loop'
      (setq lines
            (nthcdr
             (cond ((<= (length lines) total-space) 0)
                   ((> (length scroll-above) (length scroll-below)) nsections)
                   (t (min (ceiling nsections 2) (length scroll-above))))
             lines))
    ;;; ------- NON ORIGINAL HERE...
      (when icomplete--in-region-buffer
        (let ((column
               (with-current-buffer icomplete--in-region-buffer
                 (save-excursion
                   (goto-char (car completion-in-region--data))
                   (current-column)))))
          (dolist (l lines)
            (add-text-properties
             0 1 `(display ,(concat (make-string column ?\s) (substring l 0 1)))
             l))))
    ;;; -------- NON ORIGINAL ENDS HERE...
      ;; At long last, render final string return value.  This may still
      ;; kick out lines at the end.
      (concat " \n"
              (cl-loop for l in lines repeat total-space concat l concat "\n")))))

Is this patch the new default?

Not at all. As you might know, an initial "it works" does not mean it is fully tested and free of bugs, right?

I ended up not having the time to properly suggest some new features to icomplete, such as:

• Turning this "follow the cursor" feature on/off

• Providing a "callback" function where the user could customize what function is wanted to perform this action

• Providing a way to add markings, such as arrow indicators, prefixes, suffixes, or maybe icons

I thought I’d have the time, but it has been a while since April, and other projects with already delayed statuses took priority. I figured it might be a good idea to share with the community that this sort of in-buffer completion is already possible with no external packages, especially for those trying to keep their configurations more purist.

Conclusion

The enhancements to icomplete-vertical-mode presented in this post demonstrate how a small patch can significantly improve the in-buffer completion experience, making it more intuitive and aligned with modern expectations. While this solution isn't yet part of the default Emacs distribution, it shows the potential of leveraging existing tools and a bit of customization to achieve powerful results.

If you're an Emacs purist or just someone looking to simplify your configuration without relying on external packages, this approach is worth exploring. And who knows? With enough community interest, we might see such improvements integrated into Emacs in the future.

As always, feel free to share your thoughts, improvements, or challenges in implementing this solution. Collaboration is what makes the Emacs community thrive!

Edit

2024-12-25: full code included the icomplete--augment function, which we did not change. Since it was mistakenly pasted there, I removed it.

James Dyer: Calculate Number Of Days Between Two Dates

2024-12-19T13:21:00+00:00

Just a very quick one today.

I recently needed to find the number of days between two dates. I thought this would be easy in Emacs, and indeed it was, but as with most things in Emacs, you need to know exactly what you’re doing. Here is the method I used:

  M-x =calendar=

  Navigate to the start date

  Set mark

  Navigate to the end date

  M-x =calendar-count-days-region=

  OR

  M-=

Note that the count is inclusive of the mark, the documentation says:

It is bound to M-=.

Count the number of days (inclusive) between point and the mark.

That is all. 🙂

Charles Choi: Rethinking Minibuffer Movement

2024-12-19T02:30:00+00:00

For your consideration, a possible quality of life improvement in using Emacs. Typically the next-to-the-smallest unit of point movement is by word. This is reinforced by binding M-f and M-b to forward and backwards word movement respectively.

When editing prose, this is sensible. For editing code and commands, I would argue this is less so. This is because the unit of text I most want to move by is via symbol. Common examples of symbols include variable/function/class names, command line options & arguments, and Makefile targets. Symbols frequently embed non-alphabetic characters (e.g. ‘foo-bar’, ‘bar_foo’, ‘foo/bar’) which are treated as word-separators by the commands forward-word and backward-word.

Movement by symbol is what I want whenever I’m editing in the minibuffer. Muscle memory wants me to type M-f or M-b, which does the “wrong” thing here. But there are movement commands for a unit of text that handles symbols gracefully: that unit of text is called a balanced expression (aka sexp). By default, moving by balanced expression is bound to C-M-f for forwards movement, C-M-b for backwards.

Personally, I’m loathe to use keybindings involving more than two keys, so I’ve taken this tack: Swap (M-f, M-b) for balanced expression movement and (C-M-f, C-M-b) for word movement in modes that involve a lot of symbols.

Another detail to consider is moving the point so that it is at the start of a unit of text. Both forward-word and forward-sexp are implemented so that the point is set at the end of a text unit. In many cases this adds editing friction for me because what I really want is for the point to be at the start of a text unit. To allow for this, I’ve implemented a function for moving forward a balanced expression that places the point at the start of the next sexp (cc/next-sexp).

Code showing the implementation of cc/next-sexp and configuring the minibuffer to swap the bindings for word and sexp movement is shown below:

(keymap-set minibuffer-mode-map "M-b" #'backward-sexp)
(keymap-set minibuffer-mode-map "M-f" #'cc/next-sexp)
(keymap-set minibuffer-mode-map "C-M-b" #'backward-word)
(keymap-set minibuffer-mode-map "C-M-f" #'forward-word)

(defun cc/--next-sexp-raw ()
  "Raw implementation to move point to the beginning of the next sexp.

This function has no error checking."
  (forward-sexp 2)
  (backward-sexp))

(defun cc/next-sexp ()
  "Move point to beginning of the next balanced expression (sexp)."
  (interactive)
  (condition-case nil
      (cc/--next-sexp-raw)
    (error (condition-case nil
               (forward-sexp)
             (error
              (message
               "Unable to move point to next balanced expression (sexp)."))))))

The same swap can be applied when calling eval-expression (M-:). The keymap to configure here is minibuffer-local-shell-command-map.

(keymap-set minibuffer-local-shell-command-map "M-b" #'backward-sexp)
(keymap-set minibuffer-local-shell-command-map "M-f" #'cc/next-sexp)
(keymap-set minibuffer-local-shell-command-map "C-M-b" #'backward-word)
(keymap-set minibuffer-local-shell-command-map "C-M-f" #'forward-word)

Why stop there? Let’s change it for Elisp mode:

(keymap-set emacs-lisp-mode-map "M-b" #'backward-sexp)
(keymap-set emacs-lisp-mode-map "M-f" #'cc/next-sexp)
(keymap-set emacs-lisp-mode-map "C-M-b" #'backward-word)
(keymap-set emacs-lisp-mode-map "C-M-f" #'forward-word)

This idea can be extended to other modes such as Eshell.

Closing Thoughts

I’ve been living with this setup for a month now and anecdotally I’ve found this to feel “right” enough to merit making a post. For those readers who do not consider this post’s suggestion heretical, I’d encourage to give these changes a try. Perhaps you’ll find yourself pleasantly surprised.

Tim Heaney: Linen Layout

2024-12-19T00:00:00+00:00

Today's Advent of Code was so fun, I couldn't stop re-implementing it! (spoiler alert: if you haven't done the 2024-12-19 puzzle yet, stop reading now!) Here it is in Perl #!/usr/bin/env perl use v5.40; use List::Util qw(sum); use Path::Tiny; my $filename = shift @ARGV // 'example'; my $contents = path($filename)->slurp; my @paragraphs = split /\n\n/, $contents; my @towels = split /, /, $paragraphs[0]; my @designs = split ' ', $paragraphs[1]; my @ways = map { ways($_, @towels) } @designs; my $part1 = grep { $_ > 0 } @ways; say $part1; my $part2 = sum @ways; say $part2; sub ways($design, @towels) { my @v = (0) x length $design; push @v, 1; for (my $i = length $design; $i >= 0; $i--) { for my $towel (@towels) { my $tail = substr $design, $i; $v[$i] += $v[$i + length $towel] if $tail =~/^$towel/; } } return $v[0]; } Python

Irreal: Building Emacs Configurations

2024-12-18T16:06:46+00:00

Jack Baty has a post that considers the best way of building an Emacs configuration. On the one hand, something like Doom Emacs provides a complete, no-brainer configuration that requires little effort on the part of the user. On the other hand, some people want to build their own and while they may accept some help basically want to be in complete control.

A curmudgeon might suggest that those in the former class consider moving to something like VS Code. After all, that’s the strength of editors like VS Code: no thought configuration that works out of the box. But that’s not really fair. Emacs is, for sure, a DYI editor kit but some folks just want to enjoy its superior editing environment without having to build it for themselves. One of the glories of Emacs is that you can have it either way.

For my part, I would never want to use a prepackaged configuration. From the beginning of my career—from my n00biest of n00b days—I have hated black boxes. Every time I found one—usually in the form of a library routine—I had to peek inside to see what was really happening. My Emacs configuration is the same: I want to understand everything that’s going on.

I could, of course, use something like doom and figure what was going on but why? An Emacs configuration is—or should be—highly personal, sculpted to precisely fit your workflow. It’s true that building it piece-by-piece will take longer but in the end you will have something that fits your needs exactly and that you understand completely.

Thanos Apollo: Progress update on org-gnosis & a graphical interface addition.

2024-12-18T00:00:00+00:00

org-gnosis node & my fork of org-roam-ui

Project Name: org-gnosis | Organization of Gnosis

I’ve been working on a “roam-like” note taking system, to replace & update my current org-roam workflow. This post is a minor update on the current state of it’s development.

Goals

The goals of org-gnosis are as follows:

Keep it minimal, only implement parsing & input data to a database.
- Do not want to exceed 700 lines of code, currently it’s at 490.
Incorporate nodes as sources for gnosis notes.
- Having nodes as sources can replace my extras section.
Make it easily extensible
- Parsing functionality of org-gnosis should be easily customized to work with other note taking tools.
Separate journals from note taking

How things are going

The goals above have been achieved, except for the incorporation with my SRS system & it’s customization to parse non org-mode buffers can be kinda tricky. Despite that, it has been a drop-in replacement for my previous org-roam workflow.

I’ve also created a fork of org-roam-ui that I’ve been using to visualize my notes. I will be testing this package and hopefully publishing on either nongnu elpa or melpa soon.

If you are interested, try it out from this repo here. If you find any issues or got any questions feel free to email me.

Rahul Juliato: How to Share Your Emacs Configuration Between Different Machines (and Architectures) with Native Compilation

2024-12-17T17:00:00+00:00

How to Share Your Emacs Configuration Between Different Machines (and Architectures) with Native Compilation

If you use Emacs on multiple machines, especially ones running different architectures or operating systems, sharing your Emacs configuration across those machines can become tricky. Add native compilation (introduced in Emacs 28) to the mix, and you might run into conflicts when Emacs tries to reuse compiled .eln files between machines.

Fortunately, with a bit of smart configuration, you can make Emacs share your configuration while keeping native compilation enabled for each machine. In this post, I'll show you how to set up your Emacs so that native compilation caches (.eln files) are kept separate for each machine. We'll also discuss why this is important and what your directory structure will look like.

Why Is This Important?

Emacs uses native compilation to compile Elisp files into optimized .eln binaries, which are architecture and system-dependent. If you share your Emacs configuration across machines without accounting for this, you may encounter issues:

Conflicting .eln files: A .eln file compiled for a Linux machine might not work on a macOS machine.
Unnecessary recompilations: Emacs may attempt to recompile packages on each startup, which can slow things down and clutter your eln-cache directory.

By separating the native compilation cache for each machine, you ensure:

• Faster startup times since Emacs doesn't recompile already-compiled code.

• A cleaner and more predictable setup across machines.

The Solution: Machine-Specific `eln-cache` Directories

To keep .eln files organized and avoid conflicts, you can configure Emacs to use a machine-specific eln-cache directory. Here's the configuration snippet to add into your early-init.el:

;;; Native Compile Settings
;; I use a <emacs-default-dir>/eln-cache-<machine-hostname>/ dir to store
;; my different machines' eln compiled code. This allows the same config
;; to be used on several machines without conflicts.
;; This is added in early-init.el to prevent unwanted recompilations.

(when (featurep 'native-compile)
  ;; Set the right directory to store the native compilation cache
  (let ((path (expand-file-name (concat "eln-cache-" (system-name) "/") user-emacs-directory)))
	(setq-default native-comp-eln-load-path       (list path)
				  native-compile-target-directory path)
	(startup-redirect-eln-cache path))

  (setq-default native-comp-async-report-warnings-errors nil  ;; Silence compiler warnings as they can be disruptive
				native-comp-jit-compilation              t    ;; Enable async native compilation
				package-native-compile                   t))) ;; Compile installed packages

What Does This Code Do?

(system-name): Retrieves the hostname of the machine. This is used to create a unique directory for each machine's eln-cache.
expand-file-name: Combines the Emacs configuration directory (user-emacs-directory) with the machine-specific eln-cache-<hostname> folder.
native-comp-eln-load-path and native-compile-target-directory: Set the paths for Emacs to store and load the compiled .eln files.
startup-redirect-eln-cache: Ensures Emacs uses the specified eln-cache directory right from startup.

Optional settings:

• native-comp-async-report-warnings-errors: Silences disruptive compiler warnings.

• native-comp-jit-compilation: Enables Just-In-Time (JIT) native compilation for faster execution.

• package-native-compile: Ensures all installed packages are natively compiled.

By placing this in your early-init.el, you make sure Emacs sets up the eln-cache directory before it starts loading packages or recompiling files.

Folder Structure Example

Let's say you have two machines, with the following hostnames:

• debian: A Linux workstation.

• macbook: A macOS laptop.

With the above configuration, your Emacs directory structure will look like this:

~/.emacs.d/
|-- early-init.el
|-- init.el
|-- eln-cache-debian/          # Cache for 'debian'
|   |-- abcdef01-abcdefgh01.eln
|   |-- xyz12345-xyzabc123.eln
|
|-- eln-cache-macbook/         # Cache for 'macbook'
	|-- abcdef01-abcdefgh01.eln
	|-- pqr67890-pqrxyz678.eln

Setting Up for a New Machine

If you're setting up Emacs on a new machine:

Clone or copy your shared Emacs configuration (e.g., from GitHub).
Make sure the above snippet is in your early-init.el.
Start Emacs. It will automatically create a new eln-cache-<hostname> directory and begin compiling packages natively for the current machine.

Conclusion

Sharing Emacs configurations across machines doesn't have to be a hassle, even when using native compilation. By directing Emacs to use machine-specific eln-cache directories, you can:

• Avoid conflicts caused by incompatible .eln files.

• Speed up startup times by preventing unnecessary recompilations.

• Maintain a clean and organized Emacs setup.

I hope with the provided configuration, you can easily manage Emacs on multiple machines—whether you're switching between Linux, macOS, or different hardware architectures.

Happy hacking!

Irreal: What’s New In Emacs

2024-12-17T16:41:45+00:00

There are lots of different types of Emacs users, of course, but two distinct classes are those, like me, who stay pretty much up-to-date and those who are stilling running old versions of Emacs and are not familiar with what the latest releases have to offer.

It’s easy to dismiss the latter class as a small, insignificant group of users but I’d guess that there are more of them than many of us suspect. Over at Lambda Land, Ashton Wiersdorf has an interesting post on what’s new in Emacs in the last decade.

Even if you stay up to date, it’s interesting to see how Emacs has progressed in the last decade. Wiersdorf’s lists several broad groups of improvement:

Completions
Eglot
Projects
Tree-sitter
Dictionary lookup
- Flyspell
- Diictionary definition lookup
Visual Line Mode
Themes
Package Manager
Emacs Ecosystem
- Magit
- Vertico
- Consult
- Corfu
- Citar

Wiersdorf also has a starter kit, emacs-bedrock that provides some of these improvements for those who would like to move up. If you’d like to update your Emacs experience, take a look at Wiersdorf’s post.

Marie K. Ekeberg: 24 Emacs packages and utilities to try while counting down to Jul/Christmas/Holidays

2024-12-17T00:00:00+00:00

There are many good Emacs packages and utilities out there. Why not pick 24 of them to count down to Jul/Christmas? That is exactly what I have done here. Maybe you can find a new package or feature to play with if you have some holidays coming up?

Protesilaos Stavrou: Emacs: two new Standard themes (‘standard-light-tinted’ and ‘standard-dark-tinted’)

2024-12-17T00:00:00+00:00

The standard-themes is my third theme-related project. Unlike the modus-themes and the ef-themes, I try to remain in line with the out-of-the-box looks of Emacs, even though I personally dislike them. The purpose of the Standard themes is to provide the missing theme framework of that default aesthetic, so that users can enjoy the customisability and stylistic consistency it brings.

The themes provide lots of customisation options, including the ability to override their palette (always check the manual). While this is a powerful feature, it only yields good results when the selection of colour values is done methodically. To make it easier for users to have a style that is like the default, but a bit more opinionated, I developed the standard-light-tinted and standard-dark-tinted themes. The former has an earthly feel to it. The latter draws inspiration from the night sky.

Both of those themes are consistent with their standard-light and standard-dark counterparts, though they deviate from them in many important details.

Below are the samples of all the themes (click to enlarge).

Standard light

Standard light tinted

Standard dark

Standard dark tinted

Part of 2.2.0-dev

I am still refining the package before publishing version 2.2.0. There are lots of other features included, such as the command that goes through all the Standard themes in rotation (plus the relevant user option).

If you do try the development version and notice any issues, please let me know.

Package name (GNU ELPA): standard-themes
Official manual: https://protesilaos.com/emacs/standard-themes
Change log: https://protesilaos.com/emacs/standard-themes-changelog
Sample pictures: https://protesilaos.com/emacs/standard-themes-pictures
Git repositories:
- GitHub: https://github.com/protesilaos/standard-themes
- GitLab: https://gitlab.com/protesilaos/standard-themes
Backronym: Standard Themes Are Not Derivatives but the Affectionately Reimagined Default … themes.

Emacs APAC: Announcing Emacs Asia-Pacific (APAC) virtual meetup, Saturday, December 28, 2024

2024-12-16T18:39:40+00:00

This month’s Emacs Asia-Pacific (APAC) virtual meetup is scheduled for Saturday, December 28, 2024 with BigBlueButton and #emacs on Libera Chat IRC. The timing will be 1400 to 1500 IST.

The meetup might get extended by 30 minutes if there is any talk, this page will be updated accordingly.

If you would like to give a demo or talk (maximum 20 minutes) on GNU Emacs or any variant, please contact bhavin192 on Libera Chat with your talk details:

Sacha Chua: 2024-12-16 Emacs news

2024-12-16T17:34:21+00:00

Help wanted:
- Org Mode requests: [RFC] The best way to choose an "action" at point: context-menu-mode, transient, which-key or embark? (was: Fwd: Org-cite: Replace basic follow-processor with transient menu?)
  - also on emacs-devel
- Org Mode requests: [TASK] Documenting ob-fortran, ob-forth, ob-sed, ob-ocaml, ob-ruby, and ob-sass (was: [TASK] Move babel backend docs from WORG to Org manual)
- Merging MPS a.k.a. scratch/igc, yet again - documentation help wanted for README-IGC, build instructions for Debian etc.
Upcoming events (iCal file, Org):
- M-x Research: TBA https://m-x-research.github.io/ Wed Dec 18 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1600 Etc/GMT - 1700 Europe/Berlin - 2130 Asia/Kolkata – Thu Dec 19 0000 Asia/Singapore
- Emacs Berlin (virtual, in English) https://emacs-berlin.org/ Wed Dec 25 0930 America/Vancouver - 1130 America/Chicago - 1230 America/Toronto - 1730 Etc/GMT - 1830 Europe/Berlin - 2300 Asia/Kolkata – Thu Dec 26 0130 Asia/Singapore
- Emacs APAC (virtual) https://emacs-apac.gitlab.io/ Sat Dec 28 0030 America/Vancouver - 0230 America/Chicago - 0330 America/Toronto - 0830 Etc/GMT - 0930 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
Emacs configuration:
Emacs Lisp:
- do-at-point: A generic action dispatcher for Emacs - simpler than Embark, uses thing-at-point
- Listful Andrew: map.el vs. other libraries through hundreds of examples
- Listful Andrew: seq.el vs. other libraries through hundreds of examples
Appearance:
- Highlight selected window by measuring and increasing contrast (@Anoncheg@techhub.social)
- Protesilaos Stavrou: Emacs: pulsar version 1.2.0
Navigation:
- James Dyer: Emacs Quick Window Pt 3 - jumping between two windows
  - Improvement: James Dyer: Emacs Core Window Jumping With Visual Feedback
Hyperbole:
- Android emacs: finger/stylus support for hyperbole buttons
Writing:
- litdb and Emacs (11:03)
Org Mode:
Completion:
- Thanos Apollo: Emacs 30 Built-in Completion UI & Styles [Video] (Reddit)
Coding:
Shells:
- Alvaro Ramirez: An experimental (e)shell pager (Reddit)
Mail, news, and chat:
- I'm attempting to write a discourse forum package for Emacs (Reddit)
Fun:
Community:
Other:
Emacs development:
New packages:
- consult-vc-modified-files: Show git modified files in a vc project with consult (MELPA)
- current-window-only: Open things only in the current window (MELPA)
- eldoc-diffstat: Make VCS diffstat available via eldoc (NonGNU ELPA)
- hindu-calendar: Arithmetical traditional Hindu calendar (panchanga) (MELPA)
- js-pkg-mode: Minor mode for working with javascript projects (MELPA)
- le-gpt: Emacs on steroids with GPT (MELPA)
- terraform-docs: Generate Terraform modules documentation with terraform-docs (MELPA)

View org source for this post

Marcin Borkowski: Changing the TODO state of an Org entry when refiling

2024-12-16T05:21:58+00:00

Preview: One of the things I do quite often is refiling Org entries to my “archive” file and marking them as DONE or CANCELED. (For some reason I can’t even remember now, I don’t use the archiving feature of Org.) It occurred to me that having Emacs change the todo state automatically would be very convenient.

Irreal: Flowmeter

2024-12-15T17:03:12+00:00

Every programmer—at least every programmer who actually programs—is familiar with the concept of flow. It’s a well established concept with lots of research to back it up even if some don’t believe in it.

The trouble is, there are lots of people who are completely unfamiliar with the idea and think nothing of interrupting a programmer for the most trivial of reasons. What to do? Some programmers have the convention that they’re not to be interrupted if they have earphones on. Others put up signs or other indications that they’re working and should not be bothered. The problem with these schemes is that the programmer has to remember to invoke them and then disable them when done.

Enter Shae Erisson. He’s developed an automatic signaling system that turns on a “Busy” sign when he’s typing into Emacs. When he stops typing, the sign changes to “Free”. It’s not foolproof, of course, because some psychopaths just won’t care and will interrupt you anyway believing that their needs, however inconsequential, take precedence over your need for focus. Still, it’s a good beginning.

The only special part of this is a magtag from Adafruit. It’s a cheap bit of kit that’s easy to program. You can see the code that Erisson used at his post. There’s code for Emacs—to detect typing—and code for the magtag to display the results.

If you work in an environment where people feel free to interrupt you for the most trivial of reasons, perhaps this will help. Take a look at Erisson’s post to see if his ideas will help you.

Protesilaos Stavrou: Emacs: custom Org clock report for my coaching

2024-12-15T00:00:00+00:00

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

In this video, I demonstrate the custom code I have to generate Org clock reports for my coaching sessions. The idea is to use the DEADLINE and CLOSED timestamps of each task to calculate their elapsed time. This way, I do not need to manually clock in to the task and then clock out of it. It is easier to not have that overhead and not to duplicate the data that is already embedded in the aforementioned timestamps.

The custom command I use will prompt me for the name of a person and the date since when to collect meetings. It will then put all the retrieved data in a new buffer and calcucate the results in a neat time table. This new buffer is not related to the underlying file I used to gather the data from: it is strictly used for reporting. My file stays free from all the extra noise.

I thus use this method to do my billing and accounting.

As I show in the video, my coach.org file is simple. Each meeting is a top-level heading. The text of the heading includes the name of the person and a description on what the meeting is about. It looks like this:

#+todo: COACH(k) | DONE(d!) CANCEL(c@)

* DONE Protesilaos Emacs deep dive
CLOSED: [2024-12-10 Tue 14:45] DEADLINE: <2024-12-10 Tue 13:00>

* COACH Protesilaos Org custom clock report
DEADLINE: <2024-12-15 Sun 17:00>

My actual file has some more data, such as a link to the email I received for scheduling the given meeting, as well as relevant quotes, and the like. All that is irrelevant for the purposes of the clock reporting though. What I show in the above code block is enough.

My custom code (part of my dotfiles)

Below is the code I am using as of this writing (2024-12-15 16:38 +0200). It is an excerpt from my Emacs configuration. Note that if I make any changes to it, I will not put them back here. Check my dotemacs for the up-to-date setup (it also includes links to the Git sources): https://protesilaos.com/emacs/dotemacs.

(defvar prot-org-clock--template-no-effort
  "#+BEGIN: clocktable :formula % :timestamp t :sort (1 . ?a) :link nil :scope nil :hidefiles t :maxlevel 8 :stepskip0 t
#+END:"
  "Clock table to use for custom clock reports.")

;; TODO 2024-12-15: This sort of thing must exist in Org, but I did
;; not find it.
(defun prot-org--timestamp-to-time (string)
  "Return time object of STRING timestamp."
  (org-timestamp-to-time (org-timestamp-from-string string)))

(defun prot-org-coach--get-entries (todo-keyword string since)
  "Get Org entries matching TODO-KEYWORD followed by STRING in the heading.
Limit entries to those whole deadline/scheduled is equal or greater to
SINCE date.

Each entry is a plist of :heading, :contents, :started, :closed."
  (or (delq nil
            (org-map-entries
             (lambda ()
               (when-let* ((case-fold-search t)
                           (started (prot-org--timestamp-to-time (or (org-entry-get nil "DEADLINE") (org-entry-get nil "SCHEDULED"))))
                           (closed (prot-org--timestamp-to-time (org-entry-get nil "CLOSED")))
                           ((re-search-forward (format "\\<%s\\>.*\\<%s\\>" todo-keyword string) (line-end-position) t 1))
                           ((org-time-less-p since started)))
                 (list
                  :heading (org-get-heading :no-tags :no-todo :no-priority :no-comment)
                  :contents (org-get-entry)
                  :started started
                  :closed closed)))))
      (user-error "No entries with heading matching `\\<%s\\>.*\\<%s\\>'" todo-keyword string)))

(defvar prot-org-coach--name-history nil
  "Minibuffer history of `prot-org-coach--name-prompt'.")

(defun prot-org-coach--name-prompt ()
  "Prompt for name of person."
  (let ((default (car prot-org-coach--name-history)))
    (read-string
     (format-prompt "Name of person" default)
     nil 'prot-org-coach--name-history default)))

;;;###autoload
(defun prot-org-coach-report (name since)
  "Produce clock report for coaching with person of NAME.
SINCE is the date (of time 00:00) to count from until now."
  (interactive
   (list
    (prot-org-coach--name-prompt)
    (format "[%s]" (org-read-date))))
  (if-let* ((since-object (prot-org--timestamp-to-time since))
            (entries (prot-org-coach--get-entries "done" name since-object))
            (buffer (get-buffer-create "*prot-org-coach-entries*")))
      (with-current-buffer (pop-to-buffer buffer)
        (erase-buffer)
        (org-mode)
        (dolist (entry entries)
          (insert (format "* %s\n%s\n\n" (plist-get entry :heading) (plist-get entry :contents)))
          (org-clock-in nil (plist-get entry :started))
          (org-clock-out nil t (plist-get entry :closed)))
        (goto-char (point-min))
        (save-excursion
          (insert (format "%s\n\n" prot-org-clock--template-no-effort)))
        (save-excursion
          (goto-char (line-end-position))
          (insert (format " :tstart %S" since)))
        (org-dblock-update))
    (user-error "No entries for name `%s'" name)))

TAONAW - Emacs and Org Mode:

2024-12-14T23:36:13+00:00

my Emacs projects file (which I call now.org) is becoming too big. The agenda is still snappy, and I can work with it, but it just looks like a pile of “stuff” that I need to do or did. I want to organize it better somehow…

#emacs #orgmode

Jack Baty: Emacs from scratch once again

2024-12-14T16:04:39+00:00

I’ve been happily using Doom Emacs again, but I missed the feeling of having built things myself. I mean, if I wanted everything done for me, I could just use Obsidian, right?

There’s a certain level of geek pride in building one’s own config, although I don’t always feel it’s worth the trouble, knowing Doom exists. Other times, however, I miss feeling the satisfaction of being in complete control of my environment. I spent the day starting over.

When I say “from scratch” I don’t mean without any help from anyone. There are things that have become defacto standards when making Emacs “nicer”, so I went hunting for a leg up.

The first option I considered was to start with minimal-emacs.d from James Cherti. I’d used this for my previous vanilla setup. It’s quite fast and the defaults are sensible. This time, though, I was hoping for a little less magic in my config. I decided to look for something else.

I ended up taking the best bits from Protesilaos’ basic and capable configuration. Prot is so pragmatic and thoughtful that it’s always valuable to look at how he does things.

Something Doom is very good at is fast startup. With all my crap included, Doom would start in about 1.5 seconds. It’s one reason I moved back to Doom in the first place, as my config had blown up to around 8 seconds and I didn’t have the energy to optimize it. My unofficial target for the new config was under 4 seconds. I don’t launch Emacs that often. A few seconds once or twice a day won’t kill me.

I brought over the particulars from my earlier configs (for Org-mode, LaTeX, org-journal, etc.) and, long story short, I have a leaner, newer configuration that I (sort of) built myself. Startup is around 3 seconds, so I have a bit of room if I need it. Or maybe I’ll learn about garbage collection and compilation and see if I can improve things.

One thing I didn’t bring along was Evil mode. I don’t know if I want to run Emacs without it, but I’m going to try living with stock Emacs bindings with some tweaks. We’ll see how it goes.

There’s no public repo for this yet. I worry that my cobbled together stuff would do more harm than good if someone started copying things from it. Maybe later.

Irreal: Analog Vs. Digital Again

2024-12-14T15:53:49+00:00

Every time I think I’m done with the subject of analog versus digital notes, JTR makes another interesting post on the subject. His latest offering says he’s capitulated to the inevitable and is writing his notes digitally. Still, he says, he has a yearning for the physical. He wonders if perhaps he should print it out.

In the comments Jack Baty says he prints out his journal every month. That’s not too interesting but Baty goes much further. He prints out his journal every month and once a year he binds them into a perfect binding booklet.

The result is basically a book. He exports his journal to LaTeX and adds lots of pictures. The result is very nice: a yearly physical journal that he or anyone else can read and enjoy. Baty’s comments includes some pictures if you’re interested.

It’s a nice solution if you feel that you need a physical copy of your notes but I remain unconvinced. I know lots of people, including Sacha Chua, like to have a physical copy of their work but I just don’t see the advantage. The digital copy is right there to read and enjoy and you can also search it and add links to and from it if the need arises.

I love writing my notes in Org and having them available for future reference. If I want to share them, it’s easy to export them to HTML, PDF, or even—ugh—docx. I see no reason for filling up my home with reams of paper that, truth to tell, I will hardly ever read. But they’re great for collecting dust.

Planet Emacslife

Irreal: PSA: Use The Lucid Toolkit

Protesilaos Stavrou: Emacs: sequence notes with new ‘denote-sequence.el’

What is Denote

Irreal: Why You Want Your Tools To Be Programmable

TAONAW - Emacs and Org Mode: How I handled projects in Emacs org-mode in 2024

Footnotes

Protesilaos Stavrou: Emacs: sxhkdrc-mode version 1.1.0

The Outline of a file is more refined

Syntax highlighting includes the dot in command names

Alvaro Ramirez: Hello emacs.tv

23 December 2024 Hello emacs.tv

We need your help

Submit more content

Improve our tagging

Take it for a spin

Irreal: 24 Emacs Packages To Try During The Holidays

Marcin Borkowski: Watching variable changes

Sacha Chua: 2024-12-23 Emacs news

Meta Redux: State of CIDER Survey (2024)

Alex Popescu: easysession.el Emacs Package for Handling Sessions

Kisaragi Hiu: Emacs: turning parsed XML/HTML nodes back into text (encoding/printing/writing it out)

Christian Tietze: Fold Search Results Away in rg.el

My Previous Attempt That Is Actually Broken: Inserting a Form Feed

whatacold: Getting Started with Cider for Clojure Programming

Ruslan Bekenev: Emacs: quick-calc

Arne Bahlo: My favorite things of 2024

Music

Books

Apps

Goods

Irreal: Emacs 30.0.93

Irreal: Don’t Leave Home Without It

Andrey Listopadov: Extending Emacs with Fennel

Running Fennel from Emacs Lisp

Data conversion

More examples

Running ELisp from Fennel?..

Fennelmacs

Irreal: A Bit More On Guile Emacs

Sacha Chua: subed.el: Tweaking subtitle times

Rahul Juliato: Enhancing icomplete-vertical-mode in Emacs

The issue

A Proposed Solution

A hacky copy/paste & try it

Is this patch the new default?

Conclusion

Edit

James Dyer: Calculate Number Of Days Between Two Dates

Charles Choi: Rethinking Minibuffer Movement

Closing Thoughts

Tim Heaney: Linen Layout

Irreal: Building Emacs Configurations

Thanos Apollo: Progress update on org-gnosis & a graphical interface addition.

Goals

How things are going

Rahul Juliato: How to Share Your Emacs Configuration Between Different Machines (and Architectures) with Native Compilation

How to Share Your Emacs Configuration Between Different Machines (and Architectures) with Native Compilation

Why Is This Important?

The Solution: Machine-Specific eln-cache Directories

What Does This Code Do?

Folder Structure Example

Setting Up for a New Machine

Conclusion

Irreal: What’s New In Emacs

Marie K. Ekeberg: 24 Emacs packages and utilities to try while counting down to Jul/Christmas/Holidays

Protesilaos Stavrou: Emacs: two new Standard themes (‘standard-light-tinted’ and ‘standard-dark-tinted’)

Standard light

Standard light tinted

Standard dark

Standard dark tinted

Part of 2.2.0-dev

Emacs APAC: Announcing Emacs Asia-Pacific (APAC) virtual meetup, Saturday, December 28, 2024

Sacha Chua: 2024-12-16 Emacs news

Marcin Borkowski: Changing the TODO state of an Org entry when refiling

Irreal: Flowmeter

Protesilaos Stavrou: Emacs: custom Org clock report for my coaching

My custom code (part of my dotfiles)

TAONAW - Emacs and Org Mode:

Jack Baty: Emacs from scratch once again

The Solution: Machine-Specific `eln-cache` Directories