Recently:

Irreal: Charles Choi Imagines Some New T-Shirts

I wear T-shirts pretty much exclusively but I don’t have any Emacs T-shirts. The designs just don’t appeal to me. Charles Choi to the rescue. I really like the first two.

Choi generated them with Gemini as a lark so they’re not really available but I’m sure it would be easy to get some made by providing the images to any of several companies that silk screen T-shirts.

Regardless, this is just a quick, whimsical post to help you get over hump day

-1:-- Charles Choi Imagines Some New T-Shirts (Post Irreal)--L0--C0--2025-08-06T15:48:59.000Z

Protesilaos Stavrou: Prot Asks: James about biology teaching, Emacs, and free software politics

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

In this new video series, I talk to anybody who is interested to have a video call with me (so do contact me if you want!). The topics cover anything related to Emacs, technology, and life in general. More here: https://protesilaos.com/prot-asks/.

In this 1-hour video, I learn from James about what goes into teaching biology and thinking as a scientist. We discuss the shortcomings of the education system and touch on the alternative approach of going more in-depth. James describes how Emacs comes into the picture, the importance of the free software community—and community in general—and how politics informs our views on competition and cooperation.

  • James teaches at the Pennsylvania State University: https://science.psu.edu/bmb/people/jeh37
  • Personal website: https://jamesendreshowell.com/
  • EmacsConf 2023 presentation about teaching at the university with free software: https://emacsconf.org/2023/talks/uni/
-1:-- Prot Asks: James about biology teaching, Emacs, and free software politics (Post Protesilaos Stavrou)--L0--C0--2025-08-06T00:00:00.000Z

Protesilaos Stavrou: I got the Emacs Writing Studio (EWS) book

The Emacs Writing Studio (EWS) by Peter Prevos is a configuration for Emacs designed for writers, researchers, and scientists. It provides an integrated environment to express one’s thoughts and publish them in multiple formats. The book, which is produced using EWS, documents the setup, describes relevant methods or workflows, and explains how everything is pieced together. I contributed the foreword.

This morning, I got the paperback version of the book. It is a thing of beauty!

EWS front cover

EWS dedication

Thanks to Peter for working on this and for showing how Emacs can also be used as a professional publishing tool.

Emacs Writing Studio sources

Buy the book, check the source code, and watch the videos:

Also read the Why Use Emacs essay on Peter’s website: https://lucidmanager.org/productivity/why-use-emacs/.

-1:-- I got the Emacs Writing Studio (EWS) book (Post Protesilaos Stavrou)--L0--C0--2025-08-06T00:00:00.000Z

Yi Tang: Terminating Ethernet Cable At Height For CCTV Cameras

On the Ground

The standard Cat 6 plug is a pain to work with: I have to untwist the 4 pairs, make them perfectly straight, lay the 8 wires side by side with no gaps, and then insert all of them into the RJ45 plug in one go.

It sounds easy, but since the wires are flexible, it is actually very hard: very often the wires move around and become misaligned or misplaced during the fitting. If that happened or any other part of it went wrong, I would have to pull out the whole lot and restart again.

I had successes before, usually after a couple of attempts, often accompanied by frustration in between. It requires me to activate the fight mode, give it 100% focus while sitting in an “Orz” position1, so there’s quite a lot of energy poured into it.

At Height

However, even if I want to, it becomes physically impossible when it comes to fitting a plug in the air for the CCTV cameras: the ladder is a bit wobbly with uneven ground underneath it, and it is windy and raining due to a summer storm.

Since I wasn’t happy with the normal Cat 6 plug, I was keen to try new products. So when I first saw the IDC Punch Down to RJ45 Plug from Kenable 2, I ordered a few. It turned out to be a smart little move (this time).

This product has a built-in RJ45 plug that is already wired up, so I can skip that difficult part. All I have to do is punch down the wires into the IDC terminal. Punching down itself is very easy; I can do it half-minded with one hand.

Another benefit is that I can split the fitting into multiple steps, and I can take mini breaks for my arms between steps. Once one or two wires are inserted into the IDC terminal, it binds the cable to the plug. The binding is strong, so it hangs in the air and swings a bit with the wind with no issues. Then I take my time for the rest of the wires. If you don’t appreciate how important it is, trust me, your arms become rather fatigued when working with your hands overhead.

Footnotes

1 For people who don’t know what “Orz” stands for, “O” is head, “z” is legs and hips, and “r” is arms.

2 This post is not affiliated with Kenable

-1:-- Terminating Ethernet Cable At Height For CCTV Cameras (Post Yi Tang)--L0--C0--2025-08-05T23:00:00.000Z

Irreal: The Emacs Writing Experience: Ridenour

This is another post about the Emacs Carnival on Writing. This time it concerns a contribution by Randy Ridenour, a Philosophy Professor at Oklahoma Baptist University. I especially like stories like his because he’s a non-technical user who nevertheless made the effort to learn Emacs and bend it to his will.

You can read about his editor journey here but the interesting part, for me, is in his Emacs Writing Carnival post. If you read his previous post about his editor journey, you’ll see that he’s tried a (surprising) number of different editors but has settled on Emacs.

It was not love a first sight. Like many of us, he flirted with Emacs but had problems with it so he moved on but he kept hearing Emacs’ siren song and eventually returned. Later, he wrote his Emacs Carnival post in which he revisited his original objections to Emacs and why they no longer apply.

He notes that the mistake he made in his earlier rejection of Emacs was to think of it as just another editor that expected you to adapt to its way of doing things. Emacs, of course, is not like that. It’s often described as an editor kit or as editor building material. Once he realized that, Ridenour made his peace with Emacs and has been a faithful user for more than a decade.

He also discusses the difficulties in publishing as an Emacs using, liberal arts professor: Your end product must be submitted as a Word document. That’s not too bad when you’re a solo author because you can write in Org and export to Docx but when you have coauthors—who are almost certainly not Emacs users—sooner or later you have to descend into the seventh circle of editors and use Word or one of its siblings.

If you enjoy hearing about how others use Emacs, take a look at Ridenour’s post.

-1:-- The Emacs Writing Experience: Ridenour (Post Irreal)--L0--C0--2025-08-05T16:00:06.000Z

Chris Maiorana: Wrangling project files with includes

One of the things I really like about Org Mode is the support for file includes.

#+INCLUDE: /path/to/file

This allows you to integrate contents from another file into whatever file you’re currently working in.

I leaned heavily on this functionality when writing my Emacs For Writers handbook. I had the various chapters written and spread out across multiple files in my notes directory, and I used a “binder” file to hyperlink to those chapters as I drafted them. This kept everything organized via a simple, hierarchical list.

The “binder” file is a like a notebook or codex containing links to all relevant files in that project. For some reason, I find this easier than managing a massive project from a singular file.

But once you’ve got content spread out all over the place, how do you wrangle it into one exported document?

File include brings it all together.

I sometimes refer to these various files by temperature: hot and cold.

  • Cold files are never seen by the public. They are organizational files: binders, notes, outlines, etc.
  • Hot files are eventually exported to the public: website posts, emails, chapters of novels, and short stories, etc.

With file includes, and being able to segment documents by headings excluded or ignored by the export functions, you can really take masterful control over all your various content whether it’s spread across the file system or contained in a single working directory.

The post Wrangling project files with includes appeared first on The Daily Macro.

-1:-- Wrangling project files with includes (Post Chris Maiorana)--L0--C0--2025-08-05T12:11:52.000Z

Charles Choi: Emacs Elevator Pitch: Nerd-kitch Merch

On Reddit a couple of weeks back, u/fela_nascarfan made the post New Emacs T-Shirt which both made me laugh and inspired want for such a nerd-kitch (yet cool!) t-shirt. Something visually striking with just enough absurd would definitely start a conversation, which I think ties in well with this month’s Emacs Carnival topic “Your Elevator Pitch for Emacs”.

Sadly, the FSF doesn’t have the Emacs vaporwave merch of my dreams, but I can channel my inner Napoleon Dynamite to type into an AI prompt and see what happens.

Sharing the results of my wanton foolishness below. Who knows what happens next, but everything starts as an idea, no?

Outrun energy.

img

Outrun redux, but more old-school BSG font.

img

GTA SoCal flavor.

img

Another GTA variant.

img

Destination MIA.

img

All images generated with likely infringed IP by Gemini.

-1:-- Emacs Elevator Pitch: Nerd-kitch Merch (Post Charles Choi)--L0--C0--2025-08-05T07:15:00.000Z

James Cherti: Using Emacs vc-diff with tools such as git-crypt or Rails credentials: Handling Binary Diff Issues

Tools like git-crypt or Rails credentials provide an encryption layer for managing sensitive files within Git repositories. However, when using Emacs vc-diff on repositories protected by these tools, the diff output is incorrect because vc-diff compares the encrypted binary files directly rather than comparing the decrypted files. This occurs even when the repository is unlocked and the decrypted content is available, resulting in a failure to display meaningful diffs.

The root cause

Internally, vc-diff uses Git commands to compute diffs. However, it does not invoke them with the --textconv flag by default. Without --textconv, Git does not apply content filters, including decryption filters specified by tools such as git-crypt or Rails credentials. Consequently, Emacs vc-diff displays diffs of the raw binary files rather than the decrypted content.

The solution

A workaround for enabling human-readable diffs of encrypted files in Emacs is to modify the vc-git-diff-switches variable to include the --textconv argument:

;; Emacs vc-diff fails to produce meaningful output on git-crypt enabled
;; repositories because it does not use Git's --textconv flag by default. This
;; flag enables Git to apply text conversion filters (e.g., for encrypted files)
;; when generating diffs. Without it, vc-diff compares raw encrypted blobs, even
;; when the working tree shows decrypted content.
(unless (member "--textconv" vc-git-diff-switches)
  (setq vc-git-diff-switches (cons "--textconv" vc-git-diff-switches)))

Adding the --textconv flag to the vc-git-diff-switches variable enables Emacs vc-diff to apply the text conversion filters specified in .gitattributes. This resolves the issue by displaying the diff of the decrypted files instead of the encrypted binary files.

Further Reading

-1:-- Using Emacs vc-diff with tools such as git-crypt or Rails credentials: Handling Binary Diff Issues (Post James Cherti)--L0--C0--2025-08-04T15:19:18.000Z

Sacha Chua: 2025-08-04 Emacs news

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Mastodon #emacs, Bluesky #emacs, Hacker News, lobste.rs, programming.dev, lemmy.world, lemmy.ml, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at sacha@sachachua.com. Thank you!

View org source for this post

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

-1:-- 2025-08-04 Emacs news (Post Sacha Chua)--L0--C0--2025-08-04T13:41:13.000Z

Marcin Borkowski: org-copy-visible

I have a short tip for today. Sometimes I want to send myself my Org mode agenda for today in an email so that I can open it on my phone. (Yes, I know, this is not the optimal way – I’m currently experimenting with Organice, I’ll check Orgzly, too – but sending an email to oneself and opening it on one’s phone is not as bad as it seems.) One problem I had was that Org links were not very legible in a plain text setting. Of course, one of the promises of Org mode is that it is plain text – but still, I don’t really need to see the URLs when I just want a quick reminder of my tasks so that I can do some of them on the go.
-1:-- org-copy-visible (Post Marcin Borkowski)--L0--C0--2025-08-04T04:20:06.000Z

Protesilaos Stavrou: Emacs: new ‘oak’ and ‘pine’ doric-themes

I am working on two new themes for my minimalist doric-themes collection. Both explore the woody, earthly, chthonic motif. Here they are:

doric-oak theme sample

doric-pine theme sample

I may still make further refinements, though the character of the themes is set. Once I am done, I will publish them as part of version 0.3.0 of the package.

About the Doric themes

The Doric themes use few colours and will appear monochromatic in many contexts. They are my most minimalist themes. Styles involve the careful use of typographic features and subtleties in colour gradients to establish a consistent rhythm.

If you want maximalist themes in terms of colour, check my ef-themes package. For something in-between, which I would consider the best “default theme” for a text editor, opt for my modus-themes.

-1:-- Emacs: new ‘oak’ and ‘pine’ doric-themes (Post Protesilaos Stavrou)--L0--C0--2025-08-04T00:00:00.000Z

Jeremy Friesen: On Organizing My Notes

Introduction

What follows is my thinking through and exploring the interplay of blogging and private journaling along with developing ideas; furthering inquiry. It is “stream of thought” with little refinement early on. Instead, the refinement arrives when I start outlining my solution.

Enter the Stream (of Thought)

Organizing my notes has become a consideration of mine. My personal glossary is a mix of files. But that is proving to not be the place to develop ideas; something I’m feeling strongly about doing. Why? Because I’m interested in a more philosophical life; one that favors inquiry.

Jenny just finished Tiny Beautiful Things, a book comprised of letters to an advice column, and the underlying response. Which invariably took the form of “the answer is within you.” And I’m working through Open Socrates by Agnes Callard, in which Callard argues (convincingly) that inquiry and thinking are a social exercise, requiring two people to engage in moving towards truth and away from error.

Thinking about Organization

So why this growing compulsion to reconsider my organizational processes? I have chosen a bit of a “loose leaf” approach, with tags to help bring some structure to this pile of digital files. Yet I realized a few things, in part from my effort to move my bibliography into my note taking plus my capturing of quotes close to the bibliographic record.

Those realizations beingthat I can consolidate this information into a singular location. I have many glossary terms; and I could move that information to a single file. Maybe that’s a better approach.

Second, in my journaling habit, I’m tending to create blog posts within an entry. Which I can copy to a blog document (which is then transformed to a markdown file, which is then transformed to an HTML file that is sent out into the world). In other words, different projections of the same core concept. There is also the drive to ensure that my journal is printed. Something I also want to do with my blog. I do have a suitable print style sheet for the web-pages. To print en masse would mean to create some printable views.

Then there is a consideration of effort. Paired with the adage make the change easy, then make the easy change. That is, were I to implement something for developing thought, my intuition (honed by professional activities) is that something in my present approach will need to change. And that there is prior work, but I’m uncertain about the applicability of some of the functional processes (e.g., Zettelkasten).

So let’s clarify and state the problem: Namely, what does developing an idea look like? First, a blog and journal have a temporal linearity to them (I write today in today’s slot, tomorrow in tomorrow’s). As time moves, so does the “window” in which I typically frame my writing. Similarly a blog is often “the most recent posts at the foreground.”

I think I’m skirting around with the idea of a digital garden. While also wrestling with this wonderful habit I’ve established of journaling. Something I don’t want to jeopardize, and see as a habit with which I might stack idea development; that is coming back to a topic even as the temporal window of much of my writing processes moves past it’s point of origin.

I have this journal, which at the time of writing is some 11,500 lines in a file. I can imagine a situation in which I develop ideas in the journal; another location but one within the same file. This might afford some technical niceties provided by the writing mode (e.g., radio targets for wiki like linking).

However, I’m also considering a known weakness of the format, namely that Emacs and Org-Mode struggle with large files. I have not yet noticed that struggle, so perhaps what I have is not a large file. But I can assume that were I to continue with this habit, I would encounter that threshold. And it is unknown what that is (and I don’t really want to explore). So I’m mentally considering any solution as needing to have multiple files.

Here are some considerations:

  • Each year has its own journal; as part of my “Happy New Year”, I create a journal file for the year, and update my code to begin capturing to that journal.
  • My “ideas in development” (e.g. those that I continue to groom and tend) are in their own file.
  • I use a dynamic block to make those ideas present in the journal (for referencing via radio targets…if that works with dynamism, something to test).

In this way, all journals have access to the ideas under development. I can also envision moving blog posts into respective “journals” for each year. Or some could move to their respective “series”, which themselves are ideas in development.

I had done much of this kind of work when I moved my epigraph files into a central file. Made possible, only when I identified that I wanted to improve my tracking of a personal bibliography; namely adding just a bit of “time tracking.”

The glossary is a bit of a separate concern, one that is orthogonal to developing ideas. That is this can linger a bit longer in an unresolved state. The “write a blog from my journal” is a bit different. In shifting a blog entry to a headline, I now introduce the ability to “refile” that entry. Either via the refile command, or by cutting the containing headline and pasting it into a more appropriate location. Conforming past posts to this process and making this process work going forward are also separable tasks.

I think this also means that the nt portion of my journal capture might be short-lived. Instead favoring a point in time in the headline; something I’ve done before but considered perhaps not worth tracking as it creates additional metadata of my activity. Albeit alterable.

What I’m also considering is that my blog posts and glossary entries “clutter” the directory. Again, the idea of “loose leaf papers” feels aprapos. There is also an aspect of de-prioritizing the blog post and glossary items relative to what is in that directory. In other words, shifting those concepts into corresponding index files.

While typing out a bullet list, I realized that ideas may be wrong, but instead could be questions, points of inquiry.

  • Glossary
  • Inquiry
  • Journal, private and public (e.g. a blog post)

Removing those blog posts and glossary entries from the directory, would clear space for other things. That is reduce their gravity mass in a directory listing; or more move that gravity into the file size metadata.

Focus Time, or I Could’ve Been Reading but Chose Coding

I did spend time and work working out the start of exporting headlines. There’s some bumps, and I’m considering a deeper refactor. Namely how I might skip using the Ox-Hugo package (which is feature complete but apparently not maintained) and instead use the more general markdown exporter as the baseline.

Related to this work, I realized that I could mark this journal entry as TODO and it would show up the Org-Agenda menu. I’m considering what that will mean, but I think it helps on posts in development as well as personal inquiry, namely using the todo status of Org-Mode.

In the case of this entry, I realized I had more to “develop” so I tagged it as TODO; maybe there’s other TODO keywords to consider. I see the DRAFT and PUBLISHED as a coupled pair. And there’s TODO, DONE (maybe ABANDONED?) There might be a DEVELOPING state between TODO and DONE.

Implementation Details

The Ox-Hugo package Org-Mode derives from a Blackfriday exporter which derives from the Markdown exporter (which derives from the HTML). A biblical begats if you will.

For my initial work, with the help of the REPL; I set about the logic of validating I had a blog post to export and then setting values I’d use to write to the front-matter.

This became the export-blog-post-to-takeonrules function, which would be the means project my Org-Mode post into Hugo Markdown. The inline comments of this function tell the majority of the story.

In short:

  • Validate that we’re in a blog post
  • Set important metadata for the blog post
  • Save the buffer
  • Then perform the export of that blog post
(defun export-blog-post-to-takeonrules ()
  "Conditionally export to TakeOnRules the blog post at point.

When point is a descendant of a headline tagged as a blog post (see
`jf/denote/keywords/blogPosts'), export that headline's subtree as a
blog post to Take on Rules.

This leverages `org-export-to-file' along with the 'takeonrules
org-export backend derived from the 'md backend."
  (interactive)
  ;; Bail if we aren't in `org-mode'
  (unless (derived-mode-p 'org-mode)
    (user-error "Current buffer not 'org-mode"))
  (org-set-regexps-and-options)
  (jf/bibliography/export-to-takeonrules)
  ;; Get element at point, then walk-up ancestry tree, finding headline
  ;; node that has :blogPosts: tag.  We'll be exporting that.
  (let* ((blogPost
           (car
             (seq-filter
               (lambda (hl)
                 (and
                   (eq (org-element-type hl) 'headline)
                   (member jf/denote/keywords/blogPosts
                     (org-element-property :tags hl))
                   hl))
               (org-element-lineage (org-element-at-point) nil t)))))

    ;; Ensure we are in an entry tagged as a blog post.
    (unless blogPost
      (user-error
        "Current node is not child of headline tagged with :%s:"
        jf/denote/keywords/blogPosts))
    (goto-char (org-element-property :begin blogPost))
    ;; Ensure we set metadata that we will use in the export for initial
    ;; publication as well as future updates (if any)
    (let ((slug
            (or (org-element-property :SLUG blogPost)
              (let ((s (jf/denote-sluggify-title
                         (org-element-property :title blogPost))))
                (org-entry-put blogPost "SLUG" s)
                s)))
           (custom_id
             (or (org-element-property :CUSTOM_ID blogPost)
               (org-entry-put blogPost "CUSTOM_ID"
                 (format "blogPost-%s"
                   (jf/denote-sluggify-title
                     (org-element-property :title blogPost)))))))
      (or (org-element-property :ID blogPost)
        (org-entry-put blogPost "ID" custom_id))
      (or (org-element-property :PUBLISHED_AT blogPost)
        (org-entry-put blogPost "PUBLISHED_AT"
          (format-time-string "%Y-%m-%d %H:%M:%S %z")))
      (or (org-element-property :DESCRIPTION blogPost)
        (org-entry-put blogPost "DESCRIPTION"
          (read-string "Description: ")))
      ;; We opt only for the filename, relying on the exporter to place
      ;; the file in the correct location.
      (or (org-element-property :EXPORT_FILE_NAME blogPost)
        (org-entry-put blogPost "EXPORT_FILE_NAME"
          (format "%s--%s"
            (format-time-string "%Y%m%dT%H%M%S")
            slug))))

    ;; With all of that done, we save the buffer to ensure the
    ;; properties are set.
    (save-buffer)

    ;; Now we export the file to the correct location and open it upon
    ;; completion.  It's always a good idea to review things.
    (let* ((file
             (org-export-output-file-name ".md" t
               (f-join jf/tor-home-directory "content" "posts"
                 (format-time-string "%Y")))))
      (and (org-export-to-file 'takeonrules file nil t t t)
        (find-file-other-window file)))))

I set about configuring a takeonrules exporter via the org-export-define-derived-backend function (see configuration on Github):

(org-export-define-derived-backend 'takeonrules 'md
  :translate-alist
  '(
     (footnote-reference . org-hugo-simple-footnote-reference)
     (inner-template . org-hugo-simple-inner-template)
     (timestamp . org-hugo-simple-timestamp)
     )
  :filters-alist
  '((:filter-body org-hugo-simple-body-filter))
  :options-alist
  '((:with-toc nil "toc" nil)))

Under the hood, what’s happening is that we copy the Markdown exporter configuration, merge into that copy the above configuration. And this was all that I immediately needed to:

  • Export a more semantic HTML element for a timestamp
  • Export footnotes as sidenotes
  • Ensure that I write the correct front-matter for the blog post.

I spent a few hours refining this, and preserving the previous method. At some point, I’ll evaluate if I remove the old approach and the dependency on both the Ox-Hugo package and the ox-blackfriday package. I love what both of those packages allowed for me in my earlier days of Emacs. And now, with a better understanding of the export implementation, I can use an implementation specific to my “needs.”

Conclusion

This post is a mix of how I think and move from thinking to doing. I also think there’s likely some people who might appreciate the implementation details of the custom exporter (the code is up on Github). The time I spent writing and thinking through the problem helped me avoid some potential dead-ends.

-1:-- On Organizing My Notes (Post Jeremy Friesen)--L0--C0--2025-08-03T22:44:54.000Z

Irreal: Org Workbench

I’ve been fascinated with the Zettelkasten idea ever since i read Sönke Ahrens’ book How To Take Smart Notes. I just came across a new project by Yibie called org-workbench that marries the idea of a Zettelkasten card to all or parts of one or more Org files.

The idea is that each heading and its content is imported to a single card. Subheadings are numbered in the way that Niklas Luhmann used for his famous Zettelkasten. The cards themselves are independent of the original Org files so the cards can be manipulated without affecting the source files, although there is a facility to sync them.

On the workbench, all the cards are at the same level so it’s easy to move them up and down. That means, for example, that you can move a card from one subtree to another, something that’s not easy—without cutting and pasting—with the Org file itself.

The description isn’t clear on the exact way the package functions and I haven’t had a chance to try it out so I can’t be too specific on how it works but it seems like a nice package for anyone who likes the Zettelkasten method. Take a look at the README for more details if you’re interested.

Update [2025-08-04 Mon 11:28]: See Yibie’s comment below for some clarification on the Luhmann numbering.

-1:-- Org Workbench (Post Irreal)--L0--C0--2025-08-03T15:28:51.000Z

Mark Tomczak: Screenshots into emacs org files in Windows

Related to my previous post, I needed to resolve the need to quickly take screenshots from Windows and put them in an org file in emacs. This proved a bit more difficult than I’d hoped; triggering a screenshot in Windows from emacs is non-obvious, and my attempts to use yank-media suggested that screenshots didn’t end up on the clipboard in a way emacs could see them. Other options I could find in melpa knew how to screenshot from XWindows, but not Windows.

-1:-- Screenshots into emacs org files in Windows (Post Mark Tomczak)--L0--C0--2025-08-03T01:28:58.000Z

Mark Tomczak: I Cannot Recommend Etherpad on Sandstorm at This Time

Lately, I’ve been using Etherpad on Sandstorm to track notes and clues in the game Blue Prince. While it started okay, I cannot recommend it at this time for this application. What follows is the specific issues that I’ve encountered.

Note that this may not mean it’s not fit for any purpose, or that these things cannot be fixed (I haven’t figured out how to fix them). But here are the issues I’ve encountered, and then I’ll talk about what I’m doing instead.

-1:-- I Cannot Recommend Etherpad on Sandstorm at This Time (Post Mark Tomczak)--L0--C0--2025-08-02T19:40:19.000Z

Irreal: There’s A New Carnival In Town

After the really great July Emacs Carnival on the writing experience hosted by Greg Newman, Jeremy Friesen has stepped up to host the August carnival. This month the subject is “The Emacs Elevator Pitch”. The idea is that you have a captive audience in an elevator for the short time it takes the elevator to get to its destination and you have to explain why they should be using Emacs.

There’s some latitude. As Friesen says, maybe the elevator is just going to the next floor so your time is severely limited. But maybe it gets stuck so you can harangue your audience for the time it takes for the maintenance people to rescue you all from the elevator.

Regardless, you have some limited time to convince people they should be using Emacs. What would you say? What reasons would you offer that taking the time and making the effort to learn Emacs is a worthwhile endeavor?

My own thoughts are that Emacs is a wide ranging program that does many things and can be used in many ways. I’m not sure that I could form a convincing argument “in 25 words or less” as the TV contest ads used to say. In any event, it will be interesting to see what people come up with. If you have some ideas about the matter, write them up and let Friesen know.

-1:-- There’s A New Carnival In Town (Post Irreal)--L0--C0--2025-08-02T16:25:10.000Z

Zac Romero: Searching Denote Notes With p-search

p-search is a local search-engine I developed for Emacs. I haven’t publicized it too much, mainly due to being extremely busy with a newborn, but I’m slowly working on resuming development on it. In this post, I want to dive into a particular use case that I feel many might find helpful: searching a local denote repository.

Background

The typical way that searching is done locally is via a tool like grep. You think of the term you want to search for, run grep, and get back a list of all entries using that term. This obviously works very well and has been quite effective for decades. Problems start to arise when you have too many matches.

-1:-- Searching Denote Notes With p-search (Post Zac Romero)--L0--C0--2025-08-02T03:33:38.000Z

TAONAW - Emacs and Org Mode: Thinking about organizing my RSS stuff

Today, I stumbled upon Moly White’s Curate your own newspaper with RSS:

Curate your own newspaper with RSS citationneeded.news

Citation Needed
>

To the readers of this blog, there’s nothing really new here. RSS is how we have been reading our articles for a very long time. This is true ( maybe especially true) for social media; I can see if there’s anything worth logging in for on Reddit before I expose my eyeballs to pesky ads. By the way, I just learned Bluesky offers RSS too, as they should.

However, reading this article and thinking more about how I read stuff made me realize that my current state of content consumption is chaotic.

I mostly read RSS feeds on my Android, because I just happen to have it nearby whenever I’m not on the computer doing something. It’s easy to grab when I need to use the bathroom or before I go to sleep. I know I’m going to read mostly interesting things because, as Moly says, it’s my own newspaper. But I also read RSS feeds on Emacs using Elfeed, and the feeds I have there are not the same as I have on Feeder. Meanwhile, I have another database in Feedly on my iPhone, which I use less, but still.

Having different feeds on different devices is problematic enough, but there’s another somewhat related issue.

Micro.blog, where I host my blog, is a special social network and a collection of blog-related tools on top of being a place to host this website. One of those useful tools I use all the time is the platform’s “read it later” tool, which they call “Bookmarks.” Saved articles in Bookmarks are stripped of ads and annoying pop-ups for comfortable reading (similar to “reader mode” in other browsers). They are also stored automatically in the cloud, so I can get back to them much later, even years later, and it would still be there with the relevant images and everything. Though different from RSS, there’s yet more content I want to read. If RSS is the newspaper, Micro.blog’s Bookmarks are the drawers of my desk, containing clips from all kinds of news outlets, blogs, even stuff like manuals for home appliances when I’m too lazy to put them in org-mode.

My content consumption is literally all over the place(s).

This morning I was looking into some solutions in the form of an RSS server which will work well with Elfeed in Emacs. The reason integration with Emacs is important (besides the obvious answer, “duh, it’s Emacs”) is that this is also where I write my posts. Ideally, I could follow up on everything I read from inside Emacs, find my comments about it, and write a draft. And guess what! I just found out that Micro.blog offers an RSS private feed to each user’s Bookmarks page. I shouldn’t be surprised when it comes to Micro.blog, RSS is king1.

Having my devices “talk” to each other and figure out which articles I read and from where would be great, especially since I don’t necessarily have all my feeds in one place. For example, I follow Hacker News only on my iPhone, and my Android’s Feeder contains a few gems from Kagi’s small web RSS feed which I don’t have in Elfeed yet. I just need to figure out how to start organizing this mess.

Footnotes

Footnotes

1 : not directly related, but on the topic of RSS: Micro.blog allows you to integrate RSS feeds directly into your blog, which in my opinion is one of its killer features. I mentioned it before, but my Movies and Games categories, where I rate both, are not even written on this blog; these are posts from my letterboxd and backlogged accounts, which integrate into the blog and look like my posts.

-1:-- Thinking about organizing my RSS stuff (Post TAONAW - Emacs and Org Mode)--L0--C0--2025-08-02T00:42:30.000Z

Protesilaos Stavrou: Prot Asks: Diego about Emacs use, head of engineering, industry’s state, and combat sports

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

In this new video series, I talk to anybody who is interested to have a video call with me (so do contact me if you want!). The topics cover anything related to Emacs, technology, and life in general. More information in the announcement I posted: https://protesilaos.com/codelog/2025-07-10-prot-asks-chats-videos-proposal/.

For this meeting, I learn from Diego about how he used Emacs to organise his life and do programming. As the head of an engineering team, Diego describes how the work is organised and what kind of considerations are involved. Part of our discussion covers the state of the industry and the impact of artificial intelligence. We also talk about life in the countryside of Spain. Diego is into combat sports, so we cover that issue as well and comment on how it relates to the human experience more broadly.

-1:-- Prot Asks: Diego about Emacs use, head of engineering, industry’s state, and combat sports (Post Protesilaos Stavrou)--L0--C0--2025-08-02T00:00:00.000Z

Jeremy Friesen: Emacs Carnival 2025-08: Your Elevator Pitch for Emacs

We’re onto month three of the Emacs Carnival and I’m hosting with the topic of “Your Elevator Pitch for Emacs.”

Those of us using Emacs have likely internalized many reasons for why we chose and keep choosing Emacs. However, in an era of a rising sea of digital slop, I’d love to read of people making a case for why one might invest time and energy in adopting or continuing to use Emacs.

And maybe that elevator is a quick one floor shift, only a blurb before the doors open; or you’re stuck in that elevator with a captive audience while the maintenance crew ambles their way to get you all out. It’s your elevator and your editor, get pitching!

Entries I’ve Received

What’s a Blog Carnival, Again?

A blog carnival is a fun way to tie together a community with shared writing prompts, and marvel at all the creative interpretations of the topic of the month. I’ve provided a couple of interpretations above, but you may think of something else entirely. That’s amazing, roll with it, that’s what makes this fun!

For future Carnivals, check out the “Carnival” page on EmacsWiki. It includes instructions, and is our community space to coordinate participants and topic ideas.

We are still needing more hosts so please volunteer if you want to host one of the months by adding your name to the “Carnival” page on EmacsWiki.

Submissions

I’ll aggregate all the submissions for July in this post. I do not yet have a contact form on this new site so you can email me at jeremy@takeonrules.com with a link to your submission.

-1:-- Emacs Carnival 2025-08: Your Elevator Pitch for Emacs (Post Jeremy Friesen)--L0--C0--2025-08-01T11:28:41.000Z

James Dyer: View-Mode - Emacs's Hidden Modal Editing Gem?



The Rabbit Hole

I’ve fallen down another rabbit hole, but then again, this is Emacs we’re talking about!

In this case it relates to a fundamental editing principle.

I was trying to understand some code, so of course that involved plenty of point/cursor navigation, scrolling, etc. After an hour or so of doing this, I started to wonder if there was a more efficient navigation method involving single keypresses. If I know I only want to view the file, then why not get rid of this modifier key nonsense? 😁 I’m aware that the basic functionality I’m talking about here is modal editing.

There are many different packages out there from boon to meow. So does Emacs have something built-in? Well, throughout my series of blog posts, I often ask this question, and the answer always comes back emphatically the same: “Why yes, of course it does!” This might be a little misleading, as though there isn’t a specific built-in that gives modal editing right out of the box, there is a mode that can be tweaked a little to achieve something similar.

View Mode

So what is the thing that’s been hiding in plain sight? Well, it is view-mode. Although strictly not a modal editing option, I think with a little tweaking I could possibly turn it into one. After a bit of internet stumbling, I came across a Reddit post from someone who has tried something similar. I think I shall add my own spin. The link is https://www.reddit.com/r/emacs/comments/fojc1y/using_viewmode_for_modal_navigation/

If you have been reading my posts over the years, you probably know my general design ethos on such a solution, and that is to use built-in Emacs-centric philosophies and to make sure it can easily be set up on an air-gapped system. Well, for this solution, I’m going to deviate slightly from this idiom and incorporate not just more Emacs-ish keybindings but also some Vim ones! My main reasoning for this is that evil-mode is very popular, and from time to time I have recourse to using Vim over ssh, and the jkhl setup does feel pretty natural.

View-mode has been part of Emacs forever, but its default keybindings feel a bit… antiquated. z and w for scroll up and down? Space for page scroll, Return for forward one line, etc. (Maybe it works in the latter case, as it is more of a legacy Unixy vibe, but really I think we should be using more Emacs-ish keybindings, and as an option, why not Vim ones, as they tend to be mutually exclusive)

The Setup

Of course, view-mode is completely customizable, so here’s my setup that combines the best of both worlds, familiar Emacs patterns and efficient Vim-style navigation:

;; Enable view-mode when entering read-only
(setq view-read-only t)

;; Enhanced keybindings
(with-eval-after-load 'view
  ;; More Emacs-ish keys

  ;; Navigation
  (define-key view-mode-map (kbd "n") 'next-line)
  (define-key view-mode-map (kbd "p") 'previous-line)
  (define-key view-mode-map (kbd "f") 'forward-char)
  (define-key view-mode-map (kbd "b") 'backward-char)

  ;; Beginning/end of line
  (define-key view-mode-map (kbd "a") 'beginning-of-line)
  (define-key view-mode-map (kbd "e") 'end-of-line)

  ;; Vim-ish keys

  ;; Quick exit to edit mode
  (define-key view-mode-map (kbd "i") 'View-exit)
  (define-key view-mode-map (kbd "j") 'next-line)
  (define-key view-mode-map (kbd "k") 'previous-line)
  (define-key view-mode-map (kbd "h") 'backward-char)
  (define-key view-mode-map (kbd "l") 'forward-char)

  ;; Page movement
  (define-key view-mode-map (kbd "u") '(lambda()
                                         (interactive)
                                         (View-scroll-page-backward 3)))
  (define-key view-mode-map (kbd "d") '(lambda()
                                         (interactive)
                                         (View-scroll-page-forward 3)))

  ;; Beginning/end of line (Vim style)
  (define-key view-mode-map (kbd "0") 'beginning-of-line)
  (define-key view-mode-map (kbd "$") 'end-of-line)

  ;; Beginning/end of buffers
  (define-key view-mode-map (kbd "g") 'beginning-of-buffer)
  (define-key view-mode-map (kbd "G") 'end-of-buffer)

  ;; Other bespoke bindings
  (define-key view-mode-map (kbd ";") 'other-window)

  (define-key view-mode-map (kbd "SPC") 'nil))

;; Quick toggle keys
(global-set-key (kbd "C-<escape>") 'view-mode)
(global-set-key (kbd "C-<tab>") 'view-mode)

;; Optional: return to view-mode after saving
(add-hook 'after-save-hook
          (lambda ()
            (when (and buffer-file-name (not view-mode))
              (view-mode 1))))

;; Visual feedback - box cursor in view mode, bar when editing
(add-hook 'view-mode-hook
          (defun view-mode-hookee+ ()
            (setq cursor-type (if view-mode 'box 'bar))))

Baby Proofing

Here’s where it gets interesting (possibly). I have a baby, and babies have this amazing ability to slam their tiny hands down on keyboards at the most inopportune moments. Nothing quite like a random key smash right in the middle of an important file!. Wouldn’t it be great to have a protective read-only shield over a file? So I decided, why not put all files into view-mode by default?, this way, accidental keypresses won’t modify anything, and I can intentionally switch to edit mode only when I actually need to make changes.

;; Enable view-mode for files by default
(add-hook 'find-file-hook
          (lambda ()
            (unless (or (derived-mode-p 'dired-mode))
              (view-mode 1))))

I’m currently using the automatic activation to see how it goes, but I have to say I’m not completely comfortable with setting files to read-only mode. Although more baby-proof, it does mean I have to activate edit mode (or deactivate view-mode) each time I want to edit a file and that doesn’t feel very Emacsy to me.

Cursor

You will notice that in the setup there is a modification of the cursor depending on the mode state. Although the modeline will indicate if view-mode is on or off, I’m actually quite liking the differentiation in editing modes to be reflected in the cursor. It is simple, and my brain is starting to recognize instinctively which mode I am in with no extra visual baggage.

Subtleties

It is also worth pointing out some more subtleties:

  • I have added the enabling of view-mode every time a file is saved. I am a habitual saver, I have no idea why (oh wait, habit!), so that means having to enter “edit mode” quite often. We shall see how this goes, but currently it means that I am not having to often flit back to view-mode after some characters are inserted as I would have saved and returned anyway!

  • In addition, there is a sneaky (setq view-read-only t) which means that toggling a file to and from read-only via C-x C-q will activate view-mode accordingly. I’m not really using this at the moment, but it could come in useful if I start thinking more in a dired manner, where I activate the edit mode in dired quite often to change filenames, so this could be muscle memory transferable. In the main, though, I don’t think setting this is going to hurt anything.

  • Another subtlety is the lambdas set for the page scroll. view-mode has quite a neat implementation for scrolling, in that, with a prefix or a defun argument, the number of lines for a scroll can be set. I don’t often like to scroll full pages or even half pages, so I typically have set only a few lines for faster scrolling, this of course is configurable to your own tastes.

  • You can see that I have added in all the basic Emacs and Vim typical navigational keys, and in the case of Emacs, stripped of the modifier. This, for me, feels much more natural, and strangely, I find myself naturally jumping between the Vim and Emacs keys, for shame!

  • I have already disabled a key within the view-mode mode-map and that is SPC, I found myself often (so far) pressing space without toggling off view-mode and that would scroll one page down - annoying!

  • If I am using the vim keys often and it might be likely I am viewing files, maybe code files and maybe I have a single horizontal split, I might just like to have a single key to jump back and forward between windows. I chose “;” for a few reasons but the main one is that the key is adjacent to the other vim navigation keys.

It is worth noting, of course, that all normal Emacs navigational keybindings are still available, so you also have that option too within view-mode.

Foibles

So far I have noticed some, lets say, foibles

  • It is not uncommon that I would want changes that I have just made and saved to be undone, but when undoing I am in view-mode, and the reversal is rejected due to the file being read only!, I might have to think about this one.

  • In org-mode, with the speed keys enabled which gives you a range of org commands from a single character when the point is at the heading start obviously can cause a conflict. For example, “s” is mapped in speed keys to narrow section, but in view-mode mode it is an incremental search.

Improvements?

  • One Idea is maybe I can auto-deactivate view-mode when a typical Emacs edit keybinding is detected, but this is fraught with edge cases, but maybe.

  • Do I go further with a vim paradigm? I’m not going to lie here I like the “x” to delete a character and “dd” to delete a whole line (C-k (kill-line) is something I use all the time). Could I add these in without having to break out of view-mode and hence preserving a flow for fast edits?, not sure.

Conclusion

Anyways, the result is a surprisingly pleasant modal editing experience so far that already feels natural in Emacs while giving me the ergonomic benefits of Vim-style navigation and comfortable single-key navigation options.

Plus, my codebase is now baby-resistant!

-1:-- View-Mode - Emacs's Hidden Modal Editing Gem? (Post James Dyer)--L0--C0--2025-08-01T07:30:00.000Z

Protesilaos Stavrou: Deep dive with @linkarzu about Emacs, NeoVim, Linux, keyboards, and philosophy

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

I had a ~2-hour-and-30-minute discussion with Christian from the @linkarzu YouTube channel: https://www.youtube.com/@linkarzu.

We talked about Emacs, the underlying idea of an integrated computing environment, how NeoVim effectively took the source of Vim and infused with the spirit of Emacs, thinking in terms of extensibility and cohesion, why purists cannot impose an arbitrary limit to extensibility, and more.

We also discuss other interesting topics, such as Debian and Arch Linux, how free software emphasises freedom, why it is okay to earn an income while contributing to free software, custom keyboards and ergonomics, my journey into computing, alcohol and substance abuse, and other issues of everyday life.

Thanks to Christian for inviting me to this chat! I had a good time and wish all the best with the @linkarzu channel!

-1:-- Deep dive with @linkarzu about Emacs, NeoVim, Linux, keyboards, and philosophy (Post Protesilaos Stavrou)--L0--C0--2025-08-01T00:00:00.000Z

Irreal: More From Casual

Charles Choi has announced some upgrades to his Casual Suite. He’s added two new interfaces along with the appropriate menus:

  1. Compile for compilation-mode and grep-mode
  2. Elisp for emacs-lisp-mode

He also makes explicit the support for an Eshell interface that he introduced earlier but didn’t write much about. Finally, a big part of this release is improved documentation, which he writes in Org mode, exports to Texinfo, and then formats as Info files and HTML.

As usual, transient menus are provided for each of the modes Choi supports. If, for example, you use the compile command all the time, you’ve likely internalized the auxiliary commands you need to negotiate the mode. On the other hand, if you only occasionally invoke compile, you may not remember all the related commands and will welcome the ability to popup a menu with those commands. As I’ve said before, having these menus available but hidden by default is a win. They only appear when you ask them to and then they disappear again.

Choi has put a lot of effort into Casual and it continues to improve and cover more areas. Irreal, as most of you know, is not a fan of menus in general but I do like the idea of a menu that pops up only when you ask for it. It’s the same concept as the excellent which-key: it’s there to help you discover commands that you don’t use often enough to remember.

-1:-- More From Casual (Post Irreal)--L0--C0--2025-07-31T15:29:24.000Z

TAONAW - Emacs and Org Mode: Denote with a different root directory on Linux only

As some of you may be aware, I prefer to keep certain things private, which means I don’t use cloud services for those. So, I wanted to have a dedicated folder for private notes on my Linux desktop, which doesn’t sync to my Mac. This sounds simple enough, but my setup makes it a bit more complicated.

For my technical documentations and blog posts, I use Denote, an excellent org-mode note-taking package from Protesilaos Stavrou (AKA Prot). By design, Denote is set up to have one root folder to work from with an option for subfolders under that folder for organization, which is what I have: ~/Sync/Notes/ is the main folder, and under it I have ~/Sync/Notes/Info and ~/Sync/Notes/Blog/, which should make sense if you’re follwing along.

~/Sync/Notes/ is under my Sync folder which is synced between my devices with Syncthing. Usually this is a good idea, since I want to have my technical notes and blog posts available to me both on Linux and on the Mac - and for that matter also on the iPhone and Android, but that’s a different story.

You’re probably starting to see the problem here. Denote is using a synced folder for its root folder, so I can’t have a “just for Linux” folder under normal circumstances. I wanted that private Linux-only folder to be at ~/Documents/private on my Linux desktop, and here we have yet another problem: the Mac has a ~/Documents/ folder as well, which I’m syncing to iCloud. Again, usually this is good: some of my work files are there, and I have a few settings saved. But if this folder was synced between my Linux and the Mac, these files will quickly be uploaded to Apple’s servers. Not good.

While Denote’s documentation notes that the upcoming release will have the option to define several folders as a list for denote-directory, this is not in production yet. So my first attempt took me through Syncthing documentation.

I knew I could ask Syncthing to ignore files using ignore patterns, and these are robust enough to work on folders as well. After a few attempts, I managed to have a ~/Sync/Notes/private folder on my Linux desktop that did not sync to my other devices.

While this works, it’s a weird workaround to have an isolated folder inside a folder meant for syncing; it’s kind of counterintuitive. Another concern: if the .stignore file with the ignore pattern was to be deleted by mistake, Sycnthing would sync that folder and its contents everywhere.

Digging deeper into my old Denote configurations, I found the solution in a Denote function that could solve it:

    (defun jr-private-denote ()
         (interactive)
         (let ((denote-directory (expand-file-name "~/Documents/private/"))
               (denote-excluded-directories-regexp "data")
               (denote-prompts '(title keywords))
               (denote-org-front-matter "
    #+title:      %s
    #+creator: JTR  
    #+date:       %s
    #+filetags:   %s
    #+identifier: %s
    #+STARTUP: inlineimages
    #+OPTIONS: num:nil
    \n"))
           (call-interactively 'denote)))

This function bypasses the regular denoate creation process (M-x denote) and changes the denote root folder to ~/Documents/private just for the purpose of this function. As well, I’ve included a few more options in the Denote front-matter, like the creator and the option to load images when the file loads. This function also excludes the /data subfolder under ~/Documents/private, which contains attachments, so I don’t create a note there by mistake.

This worked well, but it still leaves me with the problem I mentioned earlier. My configurations are stored in an org file synced inside my sync folder (so Emacs on my Linux desktop will run the same way as Emacs on my Mac, as much as possible), which means I could still run this function on the Mac, creating a private note in my Documentation folder there, and I don’t want a chance of that to happen. Besides, tweaking stuff is fun.

To fix that, I included a condition to help out:

    (defun jr-private-denote ()
      (interactive)
      (cond
       ((eq system-type 'gnu/linux)
        (let ((denote-directory (expand-file-name "~/Documents/private/"))
              (denote-excluded-directories-regexp "data")
              (denote-prompts '(title keywords))
              (denote-org-front-matter "
    #+title:      %s
    #+creator: JTR  
    #+date:       %s
    #+filetags:   %s
    #+identifier: %s
    #+STARTUP: inlineimages
    #+OPTIONS: num:nil
    \n"))
          (call-interactively 'denote)))
       ((eq system-type 'darwin)
        (message "You're using your Mac"))))

Now I have the Denote org file creation process dependent on a condition that I am running on Linux: (eq system-type 'gnu/linux). In case I’m running on Mac, (eq system-type 'darwin), I will only get a reminder that I’m using my Mac, and that’s it, nothing further will happen.

-1:-- Denote with a different root directory on Linux only (Post TAONAW - Emacs and Org Mode)--L0--C0--2025-07-31T10:54:59.000Z

Irreal: Emacs Carnival Writing Experience: Choi

As you all know, I’m really enjoying Greg Newman’s Emacs Carnival: Writing Experience blog posts by various Emacs users who do their (non-code) writing with Emacs. I’ve commented on several of them and today I want to comment on another. This one is from Charles Choi, himself a frequent subject of Irreal posts.

Choi’s contribution makes a point that is obvious when you see it but might not occur to you out of the box: a lot of the power of Emacs comes from its ability to deal with text structures. What does that mean?

To a first approximation, text editors deal with characters and their manipulation. You insert a character, you delete a character and maybe you copy or delete one or several characters and insert them somewhere else. The point is, you deal mostly with characters. Emacs is different. It recognizes various text structures in addition to characters. Trivial examples are words, sentences, lines, and paragraphs. A few other editors deal with some of those as well but Emacs deals with more.

For example, Emacs can deal with s-expressions, delimited structures such as quoted text or parenthetical text. The thing is, Emacs has several commands that deal specifically with these structures. That means that an Emacs user can think in terms of operating on those structures instead of just characters. That makes dealing with text easier and more efficient.

There’s more to Choi’s post than just this point so you should take a look at it. He mentions, for example, his Casual EditKit that makes some of those commands available in a Casual menu. Whether you like the idea of a menu or would rather internalize the commands, Emacs’ rich set of commands for dealing with text structures is a real win.

-1:-- Emacs Carnival Writing Experience: Choi (Post Irreal)--L0--C0--2025-07-30T15:55:40.000Z

Protesilaos Stavrou: Prot Asks: Rudy about Emacs for game development, Lisp hacking, and learning

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

In this new video series, I talk to anybody who is interested to have a video call with me (so do contact me if you want!). The topics cover anything related to Emacs, technology, and life in general. More information in the announcement I posted: https://protesilaos.com/codelog/2025-07-10-prot-asks-chats-videos-proposal/.

For this meeting, I learnt from Rudy about a bunch of geeky and fun issues. We discussed what it means to be “living in Emacs”. It takes a certain mindset to experiment with your tools and to understand what is going on. You eventually push against the boundaries because you take things to their full potential. Our talk covers bugs and some in-development feature of Org mode. Then we explore more themes that speak to the hacker’s heart: Scheme and Fennel for developing games within certain constraints, simple cooking, experimenting with pizza, and more!

-1:-- Prot Asks: Rudy about Emacs for game development, Lisp hacking, and learning (Post Protesilaos Stavrou)--L0--C0--2025-07-30T00:00:00.000Z

Jeremy Friesen: On Writing in Emacs

Writing is a murky business: you are never entirely sure what you are doing or when it will be finished and whether you got it right and how it will be received months or years or decades after you finish. What it does, if it does anything, is largely imperceptible business that takes place in the minds of people you will mostly never see and never hear from (unless they want to argue with you).

―Rebecca Solnit, Orwell’s Roses

This is my contribution to the Emacs Carnival 2025-07: Writing Experience, hosted by Greg Newman. For more details on past and upcoming Carnivals, check out the Emacs wiki page.

Much of my Emacs 📖 posts are around writing. They highlight a journey of discovery, one that is ever-unfolding.

At present, I’ve achieved what I consider a cruising altitude. There will be more things I add, but lately I’ve found myself pruning some dead-ends. Code I wrote that I thought I might use, but don’t.

I might leave those functions in my init.el or shuffle them off into a graveyard which I can later revisit as a code necromancer or curious archaeologist.

Of late, I’m using more of the basic functionality:

  • Capitalize word
  • Lower-case word
  • Transpose letter
  • Transpose word
  • Kill sentence

The most significant shift has been my adoption of a daily journal. I write journal entries to a single file, using the following capture template:

(add-to-list 'org-capture-templates
'("j" "Journal Entry"
   plain (file+olp+datetree
           jf/personal/filename-for-journal)
   "{{{nt(%?)}}}"
   :empty-lines-before 1
   :empty-lines-after 1
   :clock-in t
   :clock-resume t))

This appends the {{{nt(%?)}}} region into the day’s headline (e.g. “2025-07-29 Tuesday”). The nt is a macro for a “new thought”; one that I render as small caps. I type a few words within the macro to indicate that I’ve started a new writing session in my journal. Then set about writing more.

I have found that this has meant less public writing, but more writing in general. The journal habit now becoming my incubator. Sometimes I’ll go back to previous entries and write a bit more. This is me working out how I might develop ideas given the patterns I’ve already adopted.

In the I’ve written around 16,000 words in my journal. And at the end of the month, I’ll export that month to a PDF, using my Journal setup LaTeX template.

The template does a few things:

  • Prints the entries on two columns
  • Prints the URL of hyperlinks as footnotes as well as clickable links in the PDF.

In addition, each time I use an abbreviation, I append that abbreviated term to a list. And then, once I’ve processed the content, I append an abbreviations section to the PDF. Thus including a localized glossary, that is a subset of my larger glossary. I wrote about that in Extending Org-Mode Export to Include Acronyms Section.

In this “personal writing” I’m finding that my ritualization of thinking is beginning to have me consider how I might develop these thoughts. I’m also recognizing that my work in software development is creating friction in exploring my writing process.

First, I need to have the functional “needs” lead me. Second, I need to recognize that well organized and design code, while legible, does not itself tell a story. Though one might argue that going to an application’s router helps tell the application’s story. But moving through the layers of an application does not follow a linear flow of presented ideas.

-1:-- On Writing in Emacs (Post Jeremy Friesen)--L0--C0--2025-07-29T23:39:35.000Z

Charles Choi: Unleashing the Editing Superpower of Emacs

This is a contribution to the Emacs Carnival 2025-07: Writing Experience collection of posts on Greg Newman’s blog.

Emacs boosters often extol its virtues in editing text. But what does that really mean? In this post I’ll scrutinize that assertion. Hopefully by the end of this post, you’ll understand why long-time Emacs users so celebrate editing in it.

Any text editor worth its salt will let you type text into a file, save it, and subsequently edit it. The table stakes are to reliably transcribe thought into characters, typically one at a time. If that is all one wants, there really is no distinction in using Emacs over another editor.

Thoughts however do have organization and context. Editors like Emacs take advantage of this by providing features that exploit structure. The benefit for doing this is letting users work less in transcribing their thoughts to digital form.

For example, in prose, characters are grouped as words, words grouped as sentences, sentences as paragraphs. Emacs offers dedicated commands to manipulate such text structures. Implicit is the notion that Emacs is able to identify different structures in text. As text structure becomes more elaborate, richer commands can be made to edit them.

Working less to capture your thoughts is the core motivation for using Emacs.

When text is organized into different structures (character, word, sentence, paragraph, balanced expression), different commands can be defined to act on them. Emacs supports the following built-in actions for editing prose:

  • Marking
  • Copying
  • Killing (Cutting)
  • Transposing
  • Transforming (upper/lower case, capitalize )
  • Navigation ( previous, next, forward, backward)

A quick inventory shows no less than 50 commands available to edit text structures given the above. And that is just the tip of the iceberg. Support for pairing braces and quotes, templates, selection based on structure, abbreviation, completion, indentation, and navigation/movement all work in concert to help the writer to work less in achieving their end.

With all this bounty, there’s a catch. Discovering and knowing all these commands (much less their bindings) has a profoundly steep learning curve. For those few who climb it, my hat-tip to you. For the great mass of others (myself included), they forego using such commands either due to lack of awareness or because they were too cumbersome to recall. Invariably when faced with failing to recall that magic command, one ends up laboriously editing to achieve the desired result, rationalizing that it would be faster than the cost of lookup, disrupting whatever flow state they had at the time.

This is a user interface problem.

My work on Casual has been a personal effort to address the usability of accessing so many commands by applying an information architecture to a hierarchy of keyboard-driven menus. Within Casual, there is a set of menus focused on editing which I call EditKit whose top level menu is shown below:

From this menu, I’ve aggregated many commands that I’ve encountered (TIL) over my decades of using Emacs. Within this menu tree, I’ve captured commands for editing text structures, registers, and rectangles which have frustrated me in the past due to my failure to recall them.

For a look into what commands are offered in the “(e) Edit›” menu, take a deep read of this link. In particular it incorporates the ability to moving text as described in my earlier post “Moving Text Elegantly in Emacs”.

The Emacs Writing Experience and Closing Thoughts

As Emacs was designed to be extensible early on, we now have over three decades of collective work in features to support editing different text structures, all with the goal of improved efficiency. Emacs users are fortunate to have access to them as many of these features are not found in other editors. In this regard, Emacs can be seen as an “unfair” advantage.

The cumulative effect of having access to such a bounty is the net effect of letting the writer devote more time to thinking instead of mechanically wrangling characters on a screen. In using Casual, I have found such access. That said, other users might prefer a different interface. Regardless, the commands doing the work remain the same. If you can use them, you can work less to get what you want done.

Isn’t that why you wanted to use Emacs in the first place?

Links

Some links to packages and features that I’ve found useful for my Emacs writing experience.

P.S.

It's not lost on me how close this topic touches on both input method editors (IMEs) and LLMs as a means of capturing thought. They are both broad topics which I can not adequately cover in this post. That said, much of my thinking along these lines are informed by this presentation by Thomas S. Mullaney on his book The Chinese Computer - A Global History of the Information Age at the Computer History Museum in Mountain View, California. The upshot is that for everybody, "writing" using computers is evolving into a form where direct transcription is the exception and not the rule.

-1:-- Unleashing the Editing Superpower of Emacs (Post Charles Choi)--L0--C0--2025-07-29T20:45:00.000Z

Lars Ingebrigtsen: In a genre of speaking

Have you noticed how crowd-sourced “genre” tags are kinda…. a thing that exists?

That is, I got some feedback on my Emacs package for keeping track of your books, and the suggestions were eminently reasonable, so now there’s more usage instructions on Microsoft Github and stuff.

But it was also suggested that it’d be useful to add support for genres, and I was doubtful. I mean, people don’t have hundreds of thousands of books (except the ones that do), so what would the actual utility be? And besides, adding genre markers yourself would be actual work, and that’s ewwww. Work! Yuck.

Alors, I remembered that Goodreads has crowdsourced genre tags, so I could just query them? So:

And I don’t know whether that’s useful, but it’s kinda fun, eh?

However, these are crowdsourced, so:

Eh. Yeah, “Autistic Spectrum Disorder” is definitely a genre that exists.

I’ve tried to filter out most of the junk by just using the two first genre tags per book — and that helps a lot, but still…

In any case, you can edit the genres manually if it bothers you. Or just ignore the genres, really.

Anyway, you can now list books based on genre, and…

… I’ve also fixed up how book details are displayed.

And I’ve also changed the data format from a very, er, “ad hoc format” is perhaps putting it too gently… to JSON:

So that should make it easier to import into other programmes, and also allow extending the format gracefully.

And there’s, of course, support for using barcode scanners, but I’ve extended that with a kinda “serverish” mode, so that you don’t have to select Emacs (or a bookiez mode) before scanning. Just pick up the scanner and *beep*.

So there you go. I think bookiez might actually be usable now… perhaps.

-1:-- In a genre of speaking (Post Lars Ingebrigtsen)--L0--C0--2025-07-29T16:36:01.000Z

Irreal: Eric Fraga’s Emacs Writing Carnival Entry

I’ve been a long time fan of Eric Fraga’s quiet work in the Emacs sphere. He an academic who, as far as I know, doesn’t work directly on Emacs development but is nevertheless active in the community making suggestions and answering questions. If you check the Emacs Devel list or the Org Mode Devel list, you’ll see his name all over the place. He’s even stopped by Irreal a couple of times.

I was, therefore, delighted to see that he had make a contribution to Greg Newman’s Emacs Carnival Writing Experience. His experiences are worth listening to because he has been using Emacs and Org mode to write his technical papers for a long time. He works in process systems engineering so he can get away without having to make his submissions in the format whose name must not be mentioned.

His Emacs Carnival contribution discusses some of the advantages of using Emacs/Org mode for writing his papers. Those include the usual ability of combining code and prose in the same file, having the code be executable, and having it modify the prose in the file. He leverages that ability to generate diagrams and graphs directly from data in the paper. That’s a real win because the diagrams and graphs always reflect the data in the paper and don’t get out of sync.

Another example of the power of Emacs that he gives is almost trivial but vastly underrated: abbreviations. If there are words that you use all the time—especially long words or words that are difficult to spell—this can be a real time saver. See Fraga’s post for an example.

I’m really enjoying the Emacs Carnival Writing Experience and was glad to see Fraga share his views.

-1:-- Eric Fraga’s Emacs Writing Carnival Entry (Post Irreal)--L0--C0--2025-07-29T15:24:44.000Z

Rahul Juliato: Emacs Kick 0.3.0: Floating Docs, Snappy Completion, and Corfu Goodness

The 0.3.0 release of Emacs Kick lands today, bringing quiet but quality-of-life improvements while paving the way for future support in Emacs 31.

Gone is the company-mode UI. Enter: corfu, floating tooltips, rich font support, and more predictable behavior. Whether you use Emacs in GUI or terminal, the UX feels tighter, more modern, and (if you're on Emacs 31) frankly beautiful.

Let’s walk through what changed, and why this matters.


✨ What's New in 0.3.0

This release is focused on simplifying and modernizing the core experience—particularly completion and inline documentation.


🧠 Corfu replaces Company

company-mode has served us well, but it’s showing its age. In 0.3.0, it’s replaced with corfu.

emacs-kicks-corfu

This:

➖ Easily supports Nerd Fonts icons on TUI.

➖ Provides info about completion candidate on TUI (Emacs >31).

➖ Feels native and snappy.

➖ Integrates beautifully with cape, vertico, orderless, the modern minibuffer stack.

➖ Plays nice with LSP and non-LSP backends alike.

Corfu stays out of your way until you need it. Completion is now manual by default, triggered via TAB. No more random popups mid-thought.

You can re-enable auto-completion if you prefer, but the default now gives you back control.

💡 Floating Eldoc (with eldoc-box) on Emacs 31

If you're running the bleeding-edge Emacs 31, you now get floating documentation (via child-frame) out of the box using eldoc-box.

emacs-kicks-eldoc-box

That means pressing K (uppercase!) shows a clean, floating doc tooltip right next to your point.

No more jumping to temporary buffers to read type signatures or docstrings. It feels like a native IDE. And if you’re still on Emacs 30? No problem, the fallback is still the eldoc buffer.

✨ Smaller Tweaks That Matter

True to the Emacs spirit, small details make a big difference. This release includes several subtle but impactful visual and behavioral changes:

Company Mode Removed: All company-mode related packages have been fully removed for a cleaner, Corfu-native experience.

Consistent TAB Behavior: TAB is now exclusively for completion, removing the ambiguity where it might trigger indentation instead.

Quicker Dired: <leader> e d now opens dired on current working directory. This complements <leader> e e which opens the side explorer.

Cleaner Diffs: The markers used by diff-hl in the margin have been updated to clearer box-drawing characters (, ), making it easier to see new, modified, and saved changes.

Iconic Magit: When you have Nerd Fonts enabled, your Magit status buffer now includes file-type icons, giving it a richer, modern feel.

Less Noise: The automatic highlighting of the current line (global-hl-line-mode) is now off by default to reduce visual distraction.

🚀 What This Means for You

Remember this:

Emacs-Kick isn’t a full-fledged distribution
but rather a starting point for building your
own Emacs configuration. It’s designed to be
especially accessible for Vim/Neovim users,
letting you explore the power of Emacs without
committing to its entire ecosystem.

This release doubles down on that. It gets out of your way. It gives you just enough: snappy completions, modern visuals, but no monolithic frameworks.

📦 How to Upgrade

Check install instructions on the official Github Repository: https://github.com/LionyxML/emacs-kick

💬 Final Thoughts

This release makes Emacs Kick feel... well, kick-ass. It’s smoother, quieter, and more intentional. If you value clean defaults, fast completion, and less cognitive noise. You’ll feel the difference.

Let me know what you think, what broke, and what could improve. PRs and issues welcome as always.

Happy hacking! ⚡️

-1:-- Emacs Kick 0.3.0: Floating Docs, Snappy Completion, and Corfu Goodness (Post Rahul Juliato)--L0--C0--2025-07-29T15:00:00.000Z

Randy Ridenour: Emacs Writing Experience

Emacs Writing Experience

Jul 28, 2025 13:44

I’ve enjoyed reading the posts in this month’s Emacs Carnival on the topic of “Writing Experience.” It’s given me an opportunity to reflect not only on how I use Emacs to write, but also on why I continue to use Emacs despite the many alternatives that are available. I don’t consider myself to be the typical Emacs user, if there is such a person. I’m certainly not a coder; anything I learned in my single FORTRAN class thirty-five years ago is long gone by now. 1 Instead, I’m a philosophy professor at a small liberal arts university, which means that I live in a Microsoft world. It’s very likely that I am the only Emacs user on campus. I’m also a retired Army Reserve chaplain. I’m sure that Emacs users are a minority in technical fields, but they are almost non-existent in the humanities. One can only imagine how few Emacs users there are in ministry.

Everything that I produced during my undergraduate and graduate studies, including my dissertation, was written with a word processor, either WordPerfect 5.1 or MS Word 6.0. As I began working more with formal logic, I began to be aware of the power and beautiful output of LaTeX, and that led me to look for the best way to edit LaTeX files. It turns out that there’s no agreement on the internet for the best way to do anything, so my search let me down many paths. In 2012, I wrote a blog post about my experience, titled “ A Sordid Tale of Text Editors.” It documents a journey from TextMate to Vim, a brief interlude with Emacs, then back to TextMate, then to Sublime Text 2. 2 What I now find particularly interesting about that post are the three reasons why I rejected Emacs at the time:

  1. The complex, arcane key combinations,
  2. The inability to use Textexpander snippets in Gnu Emacs, and
  3. The pain of configuring Emacs for amateurs.

The second no longer applies — at the time, Emacs just wasn’t a well-behaved Mac app, but that has changed over the years. The first and third, though, are still common reasons that people cite for giving up Emacs. Shortly after I wrote that, however, I gave Emacs another try, and over a decade later, I’m still using it. More that that, though, I can’t imagine an alternative.

The mistake that I made in my earlier flirtation with Emacs was, in my opinion, treating it as just another text editor. Every other text editor that I tried demanded that I conform to its way of editing. When I realized that Emacs, with a bit of configuration work, was quite willing to conform to the way that I wanted to work, the search was over. Don’t like the keybindings? Then change them! Prefer modal editing? Emacs can do that. Do you want a file tree window to the side as with VSCode? Emacs can do that, too. The initialization files may look complicated at first, but Lisp is very straightforward and remarkably easy to follow, even for a philosopher like me. When I got stuck, I found the community to be remarkably gracious and helpful.

I do write some papers for presentation and possible publication, but our primary responsibility as faculty at my institution is teaching. So, most of my writing is for lecture notes, presentation slides, and handouts. Given our heavy teaching load (normally four courses per semester), it helps to be able to produce these as efficiently as possible. With Emacs, I’m able to write one document and, from that, produce a PDF of notes for me, slides to show in class, and and HTML handout to post in the learning management system. In short, a function creates four files: one that exports a notes PDF for me, one that exports to a LaTeX Beamer document, one that exports to HTML for posting, and a data file used by the other three. The Org headers are automatically inserted into each file, and the only file that I actually edit is the data file. Two Yasnippet snippets make it easy to specify text that appears only in the presenter’s notes in the slides and more detailed notes that appear in the lecture notes. The HTML handout includes everything in the lecture notes. An export function generates the HTML and copies it to the clipboard for pasting to the LMS. (The code for everything is in the teaching section of my configuration file.)

I use many packages, but there are some that are particularly useful for my everyday writing.

  • Jinx for spell checking.
  • I’ve already mentioned Yasnippet. I also find Yankpad can be useful for inserting snippets that are used only occasionally.
  • Orgonomic helps me quickly enter lists and headings in Org mode.
  • Math-Delimiters for quickly entering LaTeX math mode.
  • Citar makes citations simple.

Finally, I should point out that I can’t use Emacs for everything. Although everything begins in Org mode, some of it must, unfortunately, end up in Microsoft Word. I have a collaborative book project with a colleague who only uses Word, and most publishers in the humanities, including those in my particular fields of philosophy and religion, expect Word documents. That’s no problem, provided that I am the sole author. Any changes can be made to the original Org document, with a final export to a docx file. If I’m collaborating with someone else, then eventually I just have to start working in Word.

In the end, the best thing about the Emacs writing experience is that there is no such thing as the Emacs writing experience. Emacs provides a canvas and tools from which each user crafts their own editing environment. Simple or complex, modal or non-modal, Emacs can provide the writing experience you want, not merely something that just approximates it. That’s why I’m still using it.

Tagged: Emacs

Footnotes

1

The only thing that remains is a vague recollection of the pain of counting columns when debugging a program.

2

The list is actually much longer than that and it includes some editors whose names I can’t even remember now.

-1:-- Emacs Writing Experience (Post Randy Ridenour)--L0--C0--2025-07-29T12:05:00.000Z

Sacha Chua: 2019-08-12 Emacs news

EmacsConf 2019 (Nov 2, online): Propose a session: https://emacsconf.org/2019/cfp (before Aug 31) Share ideas: https://emacsconf.org/2019/ideas

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file and emacs-devel.

View org source for this post

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

-1:-- 2019-08-12 Emacs news (Post Sacha Chua)--L0--C0--2025-07-29T04:34:51.000Z

Randy Ridenour: A Sordid Tale of Text Editors

A Sordid Tale of Text Editors

May 24, 2012 00:00

For years now, It seems like I have been searching for the perfect text editor. Evidently, there are those who believe that there is one single perfect text editor for everyone. If you need evidence, just search the Internet for “Vim vs. Emacs.” My experience, though, leads to me believe that, when it comes to text editors, like many other tools, perfection is relative to the individual. What tool is needed depends on how the individual writer works and thinks.

I used word processors (beginning with WordPerfect 5.1, which I still think is the best, it’s been all downhill for word processors ever since) until I started writing LaTeX documents. I began with TeXShop, which comes bundled with MacTeX. TeXShop is an excellent resource for writing LaTeX. It’s free, powerful, and I recommend it with no reservations at all.

I don’t know why I began experimenting with other editors. I surely didn’t need any other editor to edit LaTeX. It may have been when I started writing in MultiMarkdown (MMD). Markdown, created by John Gruber, is a simple way to produce very readable documents and convert them to HTML. Markdown has grown in popularity recently, resulting in an abundance of simple Markdown editors for both OS X and iOS. I can’t remember what year I stumbled on it, but at some point I discovered Fletcher Penney’s MultiMarkdown. MultiMarkdown adds some features to Markdown, including tables and footnotes, among other things. The most important feature for me, though, was the ability to convert the document to both HTML and to LaTeX. So, I started writing in MultiMarkdown, which then gave me the ability to export the same document in several formats as needed. I could have used TeXShop to write MMD, but it wasn’t the best experience.

At the time, there was a great deal of excitement about TextMate. After watching some videos on YouTube showing LaTeX editing with TextMate, I was hooked. Then, I discovered that Fletcher Penney himself had produced a Markdown bundle for TextMate. So, I could use TextMate to easily edit an MMD document, with a quick keyboard shortcut, convert it to a LaTeX file, touch up any TeX code, then build the PDF, all from within TextMate.

But then, I started hearing things about Vim. So, I downloaded MacVim, and then spent a great deal of time learning the Vim commands and configuring my .vimrc. In my opinion, navigating files in Vim is pure magic, and I don’t think that there is anything better for editing, that is, making small corrections to an existing document.

Although I understand Vim, and can use it competently, it never quite fit the way that I work. Vim is a modal editor, which means that different modes are used for different things. For instance, insert mode is for inserting text. 1 Normal mode is used for navigating the document, among other things. The beauty of Vim is how much one can do with very few keystrokes. For instance, pressing dd deletes a sentence, and 2dd deletes two sentences. Vim experts look like sorcerers at the keyboard. Unfortunately, Vim just never quite fit for me as a tool to write longer documents, I still use it in the terminal for writing short things like Git commit statements. I would find myself starting to write after a break to think, and suddenly be inserting text in a completely different part of the document. For instance, in normal mode, e moves the cursor to the end of the word, gg moves the cursor to the beginning of the document, and i switches to insert mode. So, in normal mode, if I started typing the word “beginning” anywhere in the document, I would quickly find myself on the first line having typed ng with no idea where I started.

The problem is that I stop often to think about what I’m writing, and during these pauses, would forget what mode I was in. Now, I know the mode is clearly labeled at the bottom of the screen, but that didn’t help. The other problem is that I tend to edit as I write, which, it seems, eliminates much of the advantage that Vim offers. 2

Then, there was my flirtation with Emacs. Emacs fits the way that I write better than Vim, and I’ll keep it around. There are several reasons that Emacs doesn’t quite fit for me, though. First, I have trouble remembering the key combinations. I thought Vim’s commands were fairly intuitive, Emacs commands never quite clicked. Second, I preferred Gnu Emacs over Aquamacs for various reasons, but Textexpander snippets wouldn’t work in Gnu Emacs. Finally, configuring both Vim and Emacs can be a long painful process for amateur geeks.

So, I kept returning to TextMate, and kept telling myself that there really wasn’t anything wrong with TextMate, it worked fine. It was starting to seem a bit slow, and I found it difficult to ignore the arbiters of doom announcing TextMate’s demise, given the absence of version 2.0.

Then, the heavens opened, and a beta version of TextMate 2 appeared. I downloaded it, and it just doesn’t work as well for me as TextMate 1. I’ve had BBEdit ever since it became available in the Mac App Store. It’s nice, but it just doesn’t have the ease of TextMate for LaTeX editing. Then, I heard Brett Terpstra on the Mac Power Users podcast talk about Sublime Text 2. So, I downloaded a trial version, and showing great restraint (at least, for me) used it for three days before I bought it. It definitely appears to have been inspired by TextMate, but has many improvements over TextMate 1. It is in beta, but it seems to be solidly reliable. It is fast, edits LaTeX like TextMate, easily configurable, and beautiful.

So, Sublime Text 2, I think I’m in love, but you need to know how fickle I am. I can give you today, we’ll just have to see what the future holds.

UPDATE: It’s 2024 now, and I’ve been using Emacs for over a decade. I still like to try out new editors, but I’m no longer searching for a new love.

Tagged: Misc

Footnotes

1

Never underestimate the power of the obvious.

2

See Dr. Drang’s excellent explanation here.

-1:-- A Sordid Tale of Text Editors (Post Randy Ridenour)--L0--C0--2025-07-29T01:11:00.000Z

Protesilaos Stavrou: All my videos are mirrored on the Internet Archive (thanks to Amin Bandali)

A few days ago, Amin Bandali contacted me about the prospect of mirroring my videos to the Internet Archive. The idea is to have the option of a video hosting platform that respects user freedom. I agreed and confirmed the free/libre copyleft terms I share all my publications under (GNU GPLv3+ for code, Creative Common BY-SA 4.0 for prose, GNU FDL for my technical manuals).

Amin has since done the work and documented it here: https://kelar.org/~bandali/2025/07/25/protesilaos-videos-archive.html. The publication also points to the Python script which performs the requisite operations. The script relies on the source code of my website to extract the relevant data. Amin describes the underlying technical considerations, given the large number of videos that needed to be downloaded from YouTube and uploaded to the Internet Archive.

On my part, I made a small change to the template of my website that produces the HTML output of entries with an embedded video. Those have links to the source on YouTube and, now, to the corresponding Internet Archive page. For example, my latest “Prot Asks” video with Ihor, the Emacs Org mode maintainer, is available here: https://archive.org/details/prot-codelog-2025-07-26-prot-asks-ihor-emacs-org-maintainer-history-travel-material-science/.

These “raw links”, as opposed to the embedded frame, are also helpful for users who receive my publications via RSS/Atom feeds (and I do share the entire blog post, by the way, rather than an excerpt because that is the most convenient way to read RSS).

Thanks to Amin for this initiative!

-1:-- All my videos are mirrored on the Internet Archive (thanks to Amin Bandali) (Post Protesilaos Stavrou)--L0--C0--2025-07-29T00:00:00.000Z

Jakub Nowak: Exporting Wikis with Orgmode

One of the major boons I've found of using org-roam since my rework of my note taking environment is that I've been finding more ways to get use out of backlinks. I figured this would actually be a pretty useless feature, and I never spent so much time with it previously, but now that I'm more actively taking notes (and especially noting down random thoughts) I've found it very helpful. Being able to explore backwards through index cards has really been great for ideation, and particularly for worldbuilding.

Unfortunately, while it's great for notes, I still prefer to have a proper project structure when I'm building up the world. Generally, I've done this via Kanka because it's free, but as I've started a new worldbuilding project recently I figured I should give it a shot in Org directly. I already had some use with org-novelist (which I have stopped using), and while there isn't a direct equivalent for worldbuilding, I figured that if I structured my articles as if I was using Zettelkasten, then it may work out.

The main reason that I was using Kanka previously is because the end result is easily shareable. I won't go into the project structure of my worldbuilding setup in depth, but I want to show off the "sharing" part - publishing it as a wiki with ox-publish.

As for why I chose to use basic ox-publish over weblorg, which I use for this blog: I want to do some hacky stuff to get some wiki functionality working here, and I want a more free-form directory structure.

One other thing: I'm not using org-roam here, because I don't want to mess with having multiple DBs and I don't want to accidentally "cross-contaminate" from my personal notes to my public facing projects. That's a bad idea security-wise.

Anyhow, System Crafters has a good page on setting up a basic web project, and that's the basis of my build script. The only addition is this list to the org-publish-project-list:

(list "org-static"
      :base-directory "."
      :base-extension "css\\|js\\|json\\|png\\|jpg\\|gif\\|pdf\\|mp3\\|ogg\\|swf"
      :publishing-directory "./export"
      :recursive t
      :publishing-function 'org-publish-attachment
      )

This capture's attachments, and crucially it also captures CSS files, JavaScript files, and JSON files. The CSS is less important here, it's just for styling which can be set like this in the HTML head (base-path here is the base URL of the website):

;; Customize the HTML output
(setq org-html-head (concat "<link rel=\"stylesheet\" href=\"" base-path "/styles.css\" type=\"text/css\">"))

Just this on it's own already gives pretty exports (well, with a good stylesheet anyway). But there are two things which any good wiki needs: searching, and backlinks.

I implemented searching with Fuse: it's one JavaScript file that sits at the root of the project next to the build script. And now we get to the most disgusting Elisp code you'll ever see. I welcome any attempts to clean this up, I know it is terrible. Fuse needs a JSON file containing all the contents it should search, and I'm going to construct one by recursively going down through each org file in the project, fetching the title, filetags, and contents, then writing that to a JSON file.

(with-temp-file
  "search.json"
(insert "searchData = ")
(json-insert (vconcat (seq-filter
                       (lambda (x) x)
                       (mapcar
                        (lambda (f)
                          (when (org-publish-find-property f :title nil)
                            (list
                             :path (concat base-path (string-trim-left f "."))
                             :title (car (org-publish-find-property f :title nil))
                             :tags (vconcat (org-publish-find-property f :filetags nil))
                             :contents (with-temp-buffer
                                         (insert-file-contents f)
                                         (goto-char (point-min))
                                         (flush-lines "^#+")
                                         (org-replace-all-links-by-description)
                                         (goto-char (point-min))
                                         (flush-lines "^$")
                                         (flush-lines "^- $")
                                         (buffer-string))
                             )))
                        (directory-files-recursively "." "\\.org$"))))))

I'm prepending searchData = so that the file can be included in a script tag in the postamble, we'll see this in a bit. The :contents property is a bit confusing, so step by step:

  1. In a temporary buffer, insert the current org file, then go to the start of it.
  2. Get rid of all property lines.
  3. Replace all links with their descriptions, so getting rid of the plaintext syntax.
  4. Go back to the start of the buffer, and get rid of all empty lines.
  5. Get rid of all lines that are just a single dash - this happens in index cards where I have incomplete bullet lists.
  6. Return the whole buffer as a string.

org-replace-all-links-by-description looks like this:

(defun org-replace-all-links-by-description (&optional start end)
  "Find all org links and replace by their descriptions."
  (goto-char (point-min))
  (while (re-search-forward org-link-bracket-re nil t)
    (replace-match (match-string-no-properties 
                    (if (match-end 2) 2 1)))))

And I got that from here. Also, in case it seems a bit weird to be using vconcat to turn the list into an array, json-insert doesn't work on lists. And the seq-filter - it's for getting rid of any random null values.

Ok, all told that gives me a nice JSON file containing all the metadata I want to search. Now to search it.

In the org-html-preamble (I'll come back to this in a second), I have a search box and an empty unordered list.

<input id="search_input" type="text" placeholder="Search for...">
<ul id="search_results">

A simple JavaScript script can read when the search input is submitted, and then searches with Fuse. It will push results to the search results list:

document.getElementById("search_input").addEventListener("keypress", search);

const fuse = new Fuse(searchData, {includeScore: true, ignoreDiacritics: true, includeMatches: true, ignoreLocation: true, useExtendedSearch: true, threshold: 0.3, keys: [{name: 'title', weight: 2},{name: 'tags', weight: 3},{name: 'contents', weight: 1}]});

function search(event) {
    if (event.key == "Enter") {
      var x = document.getElementById("search_input");
      var r = document.getElementById("search_results");
      r.innerHTML = "";
      var sr = fuse.search(x.value);
      console.log(fuse.search(x.value));
      sr.forEach((result) => {
          var c = document.createElement('li');
          var a = document.createElement('a');
          var b = document.createElement('p');
          var h = document.createTextNode(result.item.title);

          a.appendChild(h);
          a.title = result.item.title;
          a.href = result.item.path.replace(/\.[^/.]+$/, ".html");

          const truncate = (input) => input.length > 125 ? `${input.substring(0, 125)}...` : input;

          b.appendChild(document.createTextNode(truncate(result.item.contents)));

          c.appendChild(a);
          c.appendChild(b);
          r.appendChild(c);
      });
    }
}

Again I am aware that this is terrible. But, when I add this, Fuse, and the search data JSON to the post-amble like so:

(setq org-html-postamble (concat
                        (concat "<script type=\"text/javascript\" src=\"" base-path "/search.json\"></script>")
                        (concat "<script src=\"" base-path "/fuse.js\"></script>")
                        (concat "<script src=\"" base-path "/search.js\"></script>")))

It all works! Search results get dredged up from the depths and shown underneath the search input bar.

Now backlinks.

This is actually conceptually simple: iterate through each org file, get a list of all the links inside it, then transpose it so that ((source-1 (target-1 target-2))) becomes ((target-1 (source-1)) (target-2 (source-1))), and write that to the page somewhere.

;; Construct backlink tracker
(defvar backlink-hashmap (make-hash-table :test #'equal))

(dolist (i (mapcar
          (lambda (f)
            (list
             (list :file (string-trim-left f "\\."))
             (list :links (mapcar
                           (lambda (l)
                             (string-trim-left (concat "/" (file-relative-name (expand-file-name l (file-name-parent-directory f)) ".")) "\\."))
                           (with-temp-buffer
                             (insert-file-contents f)
                             (org-element-map (org-element-parse-buffer) 'link
                               (lambda (link)
                                 (when (string= (org-element-property :type link) "file")
                                   (org-element-property :path link)))))))))
          (directory-files-recursively "." "\\.org$")))
  (mapcar
   (lambda (b)
     (let ((new-lst (gethash b backlink-hashmap '())))
       (remhash b backlink-hashmap)
       (puthash b
              (append new-lst (list (cadr (assoc :file i))))
              backlink-hashmap)))
   (cadr (assoc :links i))))

;; Remove duplicates
(maphash
 (lambda (x y)
   (delq nil (delete-dups y)))
 backlink-hashmap)

For the nth time, this is terrible code. You'll particularly cringe at the file name transformation crap. Regardless, it does work, and backlink-hashmap gets populated in the way we want. One thing of note here: I'm using the relative file name as the key for the hash map, which means that setting the test to equal is necessary for queries to work.

Now we can get the backlinks for anyfile with gethash and the name of our file, so we can fetch all of this data in a function for org-html-preamble:

(defun build-navigation (info)
  "Constructs navigation HTML. INFO contain all export options."
  (concat "<nav>
  <ul>
  <li>Project Name</li>
  <li class=\"float-right sticky\"><input id=\"search_input\" type=\"text\" placeholder=\"Search for...\"></li>
  <li><a href=\""
        base-path
        "/home.html\">Home </a></li>
<li><a href=\"#\">Backlinks ▾</a>
      <ul>"
        (mapconcat
         (lambda (x)
           (concat "<li><a href=\"" (concat base-path (string-trim-right x "\\.org") ".html") "\">" (car (org-publish-find-property (expand-file-name (concat "." x) (file-name-directory load-file-name)) :title nil)) "</a></li>"))
         (gethash
          (concat "/" (file-relative-name (plist-get info :input-file) (file-name-directory load-file-name)))
          backlink-hashmap))
        "</ul>
    </li>
  </ul>
  </nav>
<div>
<ul id=\"search_results\">
</ul>
</div>"))

(setq org-html-preamble 'build-navigation)

And that's it. Each page now has a drop down in the navigation bar showing all backlinks. Hopefully you learned something in this process, even if that's that I'm terrible at writing Elisp.

-1:-- Exporting Wikis with Orgmode (Post Jakub Nowak)--L0--C0--2025-07-29T00:00:00.000Z

Sacha Chua: 2025-07-28 Emacs news

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Mastodon #emacs, Bluesky #emacs, Hacker News, lobste.rs, programming.dev, lemmy.world, lemmy.ml, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at sacha@sachachua.com. Thank you!

View org source for this post

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

-1:-- 2025-07-28 Emacs news (Post Sacha Chua)--L0--C0--2025-07-28T22:32:56.000Z

Charles Choi: Announcing Casual Compile, Elisp, and Eshell

Another update to Casual has been recently made (v2.8.0) which adds two new interfaces:

  • Compile for compilation-mode and grep-mode.

  • Elisp for emacs-lisp-mode.

Belatedly, this post also announces an interface for Eshell which was released in v2.7.0 without much fanfare. We’ll remedy this here.

The v2.8.0 update also does an overhaul of the documentation for Casual, emphasizing the usage of Texinfo (by way of Org) to author it. A benefit for doing so is the ability to export its output to both Info and HTML.

Casual Compile

A common workflow is to use the compile command to run a command line tool, typically make (see also Casual User Guide (make)). If errors occur, then they are listed in a buffer named ✳︎compilation✳︎ which can be navigated upon. The major mode of this buffer is compilation-mode and it offers two ways to navigate this list:

  • Moving the current selection while simultaneously showing the selected error at its source in another window (aka “following” the selection.)
  • Moving the current selection only.

By default, the keymap compilation-mode-map binds a number of its commands to use a modifier key (M- or C-) which is too much work for my taste. I prefer a single key binding when possible, so have made the following changes for Casual Compile:

Default Binding Casual Binding Command Note
M-p k compilation-previous-error Use vi convention.
M-n j compilation-next-error Use vi convention.
M-{ [ compilation-previous-file Single key on en keyboard.
M-} ] compilation-next-file Single key on en keyboard.
C-o o compilation-display-error Single key on en keyboard.

The menu for Casual Compile (casual-compile-tmenu) is shown below:

img

This same menu also applies to Grep results when called from Emacs. This is because Grep output uses a major mode (grep-mode) that is derived from compilation-mode.

Learn more about Casual Compile in the Casual User Guide (Compile).

Casual Elisp

While I’ve been an Emacs user for decades, I’ve only been writing Emacs Lisp (Elisp) for about a year and half now. The menu I’ve created for Elisp is largely a collection of commands that I’ve found useful to have around when developing for it.

img

This includes functions for evaluation, cross-referencing, byte-compiling, and balanced expression (sexp) navigation.

Learn more about Casual Elisp in the Casual User Guide (Elisp).

Casual Eshell

Eshell has a number of commands to help save you from typing too much. Probably my most favorite command is eshell-insert-buffer-name which will let you choose a buffer via completion. This command is mapped to the binding B in casual-eshell-tmenu.

img

Learn more about Casual Eshell in the Casual User Guide (Eshell).

Casual User Guide

The User Guide for Casual has been revamped in v2.8.0. Notable features include:

  • Menu screenshots are now included in the Info file. They can be seen in the Emacs Info reader.
  • The HTML generated from the same source as the Info file is now published at https://kickingvegas.github.io/casual.
    • Supports appearance changes (light/dark mode).
    • Responsive for both mobile and desktop screens.

Closing Thoughts

Casual v2.8.0 was a big push, particularly with regards to the documentation. Please provide any feedback on any of the new features in the discussions section for it.

If you enjoy using Casual, please consider making a modest financial contribution to help support its development and maintenance. Thanks!

https://www.buymeacoffee.com/kickingvegas

-1:-- Announcing Casual Compile, Elisp, and Eshell (Post Charles Choi)--L0--C0--2025-07-28T16:00:00.000Z

Irreal: The Emacs Cat’s Org Configuration

The Emacs Cat, like me, is a heavy Org mode user. He uses it for note taking, maintaining his personal knowledge base, agenda management, and blogging. He recently decided to share his org mode configuration. It’s worth taking a look at.

The thing about Org mode is that it’s a huge app with lots of functionality and plenty of knobs that can be tuned to make it behave exactly as you want it to. So even if you’re a heavy user, it’s very possible that there’s a knob that you didn’t know about that will improve your workflow.

One way of discovering those knobs—and other functionality—is to read other people’s configurations. That’s why The Cat’s sharing of his configuration is so useful. It let’s us discover things that we didn’t know about that might be useful in our own workflows.

For example, there’s a variable, org-return-follows-link, that enables clicking on a link to open it in your browser. I generally use org-open-at-point, bound to Ctrl+c Ctrl+o, for this. It’s a bit more general but it’s still nice to have another, simple way of following a link.

There are a lot of nice suggestions in the Cat’s configuration so it’s definitely worth your while to spend a couple of minutes reading it.

The minions, of course, are upset and jumping up and down about his use of a dark theme but, minions aside, Irreal is willing to let folks use whatever themes they like. Even if the minions are right

-1:-- The Emacs Cat’s Org Configuration (Post Irreal)--L0--C0--2025-07-28T15:43:57.000Z

Donovan R.: Multiple ways of selecting text

Today, let’s talk a bit about text selection.

One of the greatest decisions I’ve ever made in my digital life a few years ago was to invest more time in Vim.
Editing, especially when working with code, just becomes so much smoother—almost addictive. The VIM-COMBO really does feel like some divine superpower bestowed upon the worthy!
And now, with Emacs and its arsenal of tools, my digital life has never been better.

Once you get a real taste of what it’s like to use powerful text editors, going back is just torture.
To give you an idea, every time I see someone struggling with the aim-and-shoot method to select text, I just want to hang myself.
It’s even worse when the person is a developer editing code. I just can’t stand it—my anxiety goes through the roof.

For anyone who’s curious, here is my own ranking of text selection methods along with some descriptions:

Level 1: Aim and shoot (for mortals)

This is where everyone starts: you point your mouse, click down, and drag to highlight your text.
If you want to get fancier, you can hold Shift and click at the end of your target area.
The drawback is, of course, you have to be better at aiming and not have shaky hands.
If you miss your aim, you have to restart the entire process.

Level 2: Ctrl Shift Arrow (superman)

This technique is used by seasoned computer users.
Park the cursor, hold down Shift and use the arrow keys to expand or reduce the selection.
Use Ctrl to select word by word instead of character by character to speed things up.
This method is good for working on short paragraphs, but it’s still painful when dealing with selections larger than your screen.
Combining this with the previous method (Shift+click) offers a better experience.

Level 3: Vim-way (God Level)

Hit v in Normal Mode to enter the Visual Mode, which starts the selection from where the cursor is.
From Visual Mode, a sea of possibilities for selection opens up before your eyes.

  • Movement: Pair Visual Mode with arrow keys or with powerful motion commands ($, 0, ^, …)
    Examples: v$ for selecting ‘til the end of the line, or v^ for the beginning.
    You can also combine this with search (/, * command) for even greater efficiency.
  • Context: describe to Vim what you want.
    Example: vi(, you are telling Vim to “select (v) inside (i) the brackets (()“. Or vi" to select inside double quote, and so on.
    The precision is just unreal! Imagine selecting everything inside curly braces across thousands of lines of code using just vi{—with 100% accuracy.

If you are interested, resources for learning Vim are available everywhere on the internet. You can pick any format you want—whether it’s articles, videos, ebooks, or even mobile applications!

Level 4: Emacs-way (Evil)

You can do everything you would normally do in Vim: set a mark and then expand your selection using search, movement,or context.
There are also some methods unique to Emacs that are sometimes even faster and more convenient than those in Vim.
For example, M-h quickly select up to the top level, like the paragraph you are in; and M-@ to select the next word.
Both can be repeatedly executed to expand your selection further.
And there is so much more Emacs can offer.

Why did I rank the Emacs-way above Vim?
That’s because the Evil-mode brings everything Vim can do—right inside of Emacs.
You have the combined arsenal of Vim and the endless toolbox of Emacs at your fingertips!

If you are interested, why don’t you grab Emacs now! 😁
https://www.gnu.org/software/emacs/

-1:-- Multiple ways of selecting text (Post Donovan R.)--L0--C0--2025-07-27T18:19:02.000Z

Irreal: Writing With Emacs: Two Out Of Three Ain’t Bad

Ross Baker, channeling the late, great Meatloaf, has a contribution to Greg Newman’s Emacs Carnival on writing with Emacs entitled Writing in Emacs: two out of three ain’t bad. The title comes from the three ways that Baker writes:

  1. Alone
  2. With asynchronous collaboration
  3. With synchronous collaboration

Baker uses Emacs and Org mode for the first two. After all, despite what anyone else might tell you, Org mode is the absolute best way of writing text that you want to do “something else” with later. By “something else” I mean, perhaps, publishing it on the Web, turning it into a PDF, or even exporting it to that spawn of the devil from Microsoft. Even if you’re just writing for yourself with no thought of exporting it, there are a lot of advantages to writing in Org mode.

It’s the third category that gives Baker problems. Lots of people—for reasons I’ve never been able to understand—like to pair program and have two or more people modifying the same piece of text simultaneously. To my mind, that’s the way to madness but plenty of serious people, like Perry Metzger, swear by it.

Regardless, if you do want to pair program it’s pretty much impossible in Emacs. Folks who need it are forced to do the unthinkable and use something like Google Docs. That’s what Baker does. He’s hopeful that Ethersync and its nascent Emacs interface will allow him to avoid the horrors of things like Word and Google Docs.

-1:-- Writing With Emacs: Two Out Of Three Ain’t Bad (Post Irreal)--L0--C0--2025-07-27T15:48:30.000Z

Ruslan Bekenev: Emacs: Keep journaling on the go

I’ve been journaling a lot for many years. It cools down my brain a little and helps me reflect on things better. Emacs and org-mode are of course the tools I use to journal.

The problem

I can’t easily journal on the go when I only have my phone handy.

Solution

I’ve built incredibly minimal web page with a simple form. When the form is submitted it is captured by a script, parses the form data and calls my Emacs with --eval to add the form data into my journal.org file.

And when I say minimal I mean it. Just look at it. simple-org screenshot

Here is its whole source code:

<html>
 <head>
 <meta name="viewport" content="width=device-width, initial-scale=2.0, maximum-scale=4.0">
 </head>
 <body>
 <form action="" method="post">
 <input name="title" type="text"/><br/>
 <textarea name="content"></textarea><br/>
 <button>submit</button><br/>
 </form>
 </body>
</html>

<?php
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
 $title = addslashes($_POST['title']);
 $content = addslashes($_POST['content']);

 # In actual file it's a oneliner.
 # I split it for this post purposes.
 # Hope it still works in case you decide to copy/paste.
 $cmd = "emacs --batch --load=\"~/.emacs.d/init.el\" --eval \"";
 $cmd .= "(progn ";
 $cmd .= " (org-capture nil \\\"j\\\")";
 $cmd .= " (insert \\\"{$title}\\\")";
 $cmd .= " (end-of-buffer) (org-return) (org-cycle)";
 $cmd .= " (insert \\\"{$content}\\\") (org-capture-finalize))\"";

 shell_exec($cmd);
}
?>

I start it with php -S 0.0.0.0:8080 and it just works. It knows what templates I use and it knows where the org-directory is.
I deployed it to my home server (just a laptop in my closet) and run it using Portainer.

My home server is constantly available for me thanks to Tailscale so I can access it outside of my home.

Why not

Why not Orgzly

Orgzly, for those who doesn’t know, is an Android app that allows to interact with org-mode files. One can import org files in it and then just update them on the go. Synchronization among machines can be done with Syncthing.

It’s very good app and I was using it for journaling a lot. Often times though, I want to add a note to my journal and then I realize that I need to create all the subheadings for today manually to follow the format I defined in my org-capture-templates. Not a big deal and it worked for awhile but it stopped me from dumping my thoughts into the journal quite a few times.

Why not Emacs on Android or Termux + Emacs

Both are great solutions as soon as one plugs in a keyboard into their phone. Using Emacs on a touch-screen is of course possible but the amount of frustration I get in the first 10 seconds of using it feels very much unjustified.

Why not run the same script on your phone locally

In this case I don’t need the whole home server setup with tailscale and portainer. Just syncthing which I already have would do the job.
Good point. I just wanted to have a bit more fun than that :)

-1:-- Emacs: Keep journaling on the go (Post Ruslan Bekenev)--L0--C0--2025-07-27T06:35:19.000Z

Protesilaos Stavrou: I will talk about Emacs on the @linkarzu YouTube channel

The @linkarzu channel on YouTube covers topics related to NeoVim, terminal emulators, and Emacs, among others: https://www.youtube.com/@linkarzu. They recently had a roundtable about “NeoVim versus Emacs” in which two members on the side of either community shared their thoughts and had a fun time together: https://www.youtube.com/watch?v=SnhcXR9CKno.

Christian, the author of @linkarzu, learnt about me via feedback about the roundtable and contacted me shortly thereafter. We agreed to have a video exchange focused on Emacs. The idea is for me to share my thoughts on the matter and demonstrate my day-to-day workflow.

The live event is for paying members of @linkarzu and can be checked here: https://www.youtube.com/live/KD9uiDdQDzI (Thursday, July 31 at 15:00 Europe/Athens). The recording of the video will be available to everyone shortly afterwards and will be free of charge.

Christian wanted to check with me if this practice is acceptable. I confirmed that it is fine by me and am looking forward to a nice chat!

Once the video is published, I will also share it on my website.

-1:-- I will talk about Emacs on the @linkarzu YouTube channel (Post Protesilaos Stavrou)--L0--C0--2025-07-27T00:00:00.000Z

Irreal: Ramírez’s Decade With Org Mode

As you all know, I’m a huge Org Mode fan but Álvaro Ramírez’s use and customization of it dwarfs mine. Yesterday, I wrote about how Ramírez was an expert at finding solutions to small problems and that those solutions can payoff by reducing some of the friction in our day-to-day chores.

In his latest post, Ramírez demonstrates this again by recounting how his use of Org Mode has evolved over the last decade. He started as many of us suggest: he chose a single task to automate with Org. That was making technical notes for his own use. But then he wanted to be able to access those from his iPhone when he was away from his computer. His solution was to simply export them to HTML—thereby learning another bit of Org Mode—and publish them so that he could access them from anywhere. He described it as accidentally falling into blogging. He’s still using the same (large) file for everything he publishes to the Web.

From there, his Org use continued to grow. Many of the apps that we associate with Ramírez actually grew out of his Org mode use. His post is fairly long and describes all this. Even his wonderful app, Journelly, grew out of his desire to integrate Org mode with his iPhone and its portability.

A lot of Ramírez’s work is available for download or purchase but perhaps the most important thing is seeing how he solved one small problem after another until he’d built up a powerful system for handling his data. If you’re an Org user or want to be one, you should definitely take a few minutes to read his post.

-1:-- Ramírez’s Decade With Org Mode (Post Irreal)--L0--C0--2025-07-26T15:17:46.000Z

Ross A. Baker: Writing in Emacs: two out of three ain't bad

I write prose in three basic modes: alone, with asynchronous collaboration, and with synchronous collaboration. Org Mode and Markdown make Emacs a productive environment for the first two. Synchronous collaboration is the sore point, but two nascent projects give me hope that Emacs can be the home for all my writing.

It starts in Org Mode #

When I write alone, for anything more than a paragraph or two in a text box, I use Emacs with Org Mode. Org Mode keeps my content decoupled from the eventual presentation. I focus on plain text and markup for structure, and then I export to the necessary format, or sometimes multiple formats.

Much of my writing is technical, and Org lets me embed and evaluate code. I can compile my examples and ensure the output is real. I define diagrams in text-based tools like Graphviz or PlantUML and render them inline.

My recent talk on understanding Scala variance employs all these techniques. I exported the article and accompanying slide deck from the same source of truth. I used Scala CLI REPL in development to verify. The inheritance diagrams are inline Graphviz.

Being a team player #

Markdown is the lingua franca for shared documentation. Most open source begins with a README.md. I work on Hugo sites for two organization. Hugo supports Org content, but it’s not Org in its full its full Lispy glory, and it’s an impediment to shared maintenance.

All is not lost. Markdown is one of Org Export’s many targets, and from there, documentation can be maintained in markdown-mode. I’m stuck with the cognitive burden of two syntaxes, but it’s easier for me than remembering the various nuances of the Markdown dialects of Hugo, GitHub, and Slack. Similar keybindings between org-mode and markdown-mode also help bridge the gap.

Beyond syntax highlighting, Markdown doesn’t provide a language-agnostic integration of code like Org Babel. I enjoy Scala’s mdoc, but I have to find bespoke solutions in all languages, which may not come together in a polyglot doc. On a brighter note, Org’s default output is close to like mdoc’s input, and Org output can be customized, so migrating existing solo docs to team maintenance isn’t so bad.

Synchronous collaboration: the last frontier #

Sometimes I’m on a Zoom call with colleagues and we need to record our ideas faster than we can push and pull and resolve conflicts from Git. Some proprietary editors have proprietary solutions, but the universal tool is Google Docs. It lacks even the comforts of Markdown, but it nails real-time collaboration. This is the use case that chases me from my beloved Emacs.

I am watching Ethersync, a “system for real-time local-first collaboration on text files”. It’s early days, and the Emacs integration “currently does not work and is not ready to be used.” I hope to be writing how wonderful they both are in a future Emacs Carnival!

-1:-- Writing in Emacs: two out of three ain't bad (Post Ross A. Baker)--L0--C0--2025-07-26T12:04:00.000Z

Marcin Borkowski: Finding entities with given uuids in the current project

One of the Node.js projects I work on has some fake/seed data in JSON files. These data are inserted into the local database during development. (Your mileage may vary – you might use Knex for seeding, or you might have your seeds as csvs or even sql files with a bunch of insert​s.) Of course quite a few tables contain some foreign keys. Sometimes I open one of the JSON files of such tables in Emacs, for example to edit some data – but it is often the case that the related data (pointed to by the foreign key) should also be changed. In cases like this it is very useful to be able to find those related data quickly. Some time ago I had the idea that it would be great if I could easily see all the data about some entity when the point is on its id.
-1:-- Finding entities with given uuids in the current project (Post Marcin Borkowski)--L0--C0--2025-07-26T07:10:06.000Z

Sacha Chua: My Emacs writing experience

I've been enjoying reading people's responses to the Emacs Carnival July theme of writing experience. I know I don't need complicated tools to write. People can write in composition notebooks and on typewriters. But I have fun learning more about the Emacs text editor and tweaking it to support me. Writing is one of the ways I think, and I want to think better. I'll start with the kinds of things I write in my public and private notes, and then I'll think about Emacs specifically.

Types of notes

Text from sketch

What kinds of posts do I write? How? Improvements?

2025-07-25-05

  • Emacs News
    • why: collecting & connecting → fun!
    • how:
      • phone: Reddit: upvotes
      • YouTube: playlist
    • RSS
    • Mastodon: Scrape boosts?
    • Dedupe, categorize: classifier?
    • Blog
    • Mailing list
    • emacs.tv
    • emacslife.com/calendar
  • Bike Brigade newsletter
    • why: help out, connect
    • Reddit + X + Slack -> Slack canvas -> MailChimp
    • Need more regular last-min sweep
    • Copying from Slack sucks; Google Docs?
  • Tech notes
    • Why: figure things out, remember, share
    • code
    • literate programming: notes + code
    • debugger?
    • more notes?
    • thinking out loud?
  • Life reflections
    • Why: figure things out, remember
    • tangled thoughts
    • sketch: habit? more doodles
    • audio braindump
    • snippets on phone
    • learning to think
    • laptop: write
    • audio input?
    • themes, thoughts
      • LLM? reflection questions, topics to learn more about
  • Book notes
    • Why: study, remember, share
    • paper: draw while reading
    • e-book: highlight
      • quotes
    • sketch
      • smaller chunks?
    • blog
  • Monthly/yearly reviews
    • Why: plan, remember
    • phone: daily journal
    • tablet: draw moment of the day
    • phone: time records
    • Emacs: raw data
    • themes, next steps: LLM? reflection questions?
    • blog post

Emacs News

I put together a weekly list of categorized links about the interesting ways people use Emacs. This takes me about an hour or two each week. I enjoy collecting all these little examples of people's curiosity and ingenuity. Organizing the links into a list helps people find things they might be interested in and connect with other people.

I start by skimming r/emacs and r/orgmode on my phone, upvoting posts that I want to include. I also search YouTube and add videos to an Emacs News playlist. I review aggregated posts from Planet Emacslife. I have an Emacs Lisp function that collects all the data and formats them as a list, with all the items at the same level.

For Mastodon, I check #emacs search results from a few different servers. I have a keyboard shortcut that boosts a post and captures the text to an Org Mode file, and then I have another function that prompts me to summarize toots, defaulting to the title of the first link. I have more functions that help me detect duplicates and categorize links. I use ox-11ty to export the post to my blog, which uses the Eleventy static site generator. I also use emacstv.el to add the videos to the Org file I use for emacs.tv.

Some ways to improve this:

  • I probably have enough data that it might be interesting to learn how to write a classifier. On the other hand, regular expression matches on the titles get most of them correctly, so that might be sufficient.
  • YouTube videos are a little annoying to go through because of interface limitations and unrelated or low-effort videos. I can probably figure out something that checks the RSS feeds of various channels.

Bike Brigade newsletter

I also put together a weekly newsletter for Bike Brigade, which coordinates volunteer cyclists to deliver food bank hampers and other essentials. Writing this mostly involves collecting ideas from a number of social media feeds as well as the other volunteers in the community, putting together a draft, and then copying it over to Mailchimp. I'm still figuring out my timing and workflows so that I can stay on top of last-minute requests coming in from people on Slack, and so that I can repurpose newsletter items as updates in the Facebook group or maybe even a blog. If I set aside some regular time to work on things, like a Sunday morning sweep for last-minute requests, that might make it easier to work with other people.

Tech notes

I like coding, and I come up with lots of ideas as I use my computer. I enjoy figuring out workflow tweaks like opening lots of URLs in a region or transforming HTML clipboard contents. My Org files have accumulated quite a few. My main limiting factor here is actually sitting down to make those things happen. Fortunately, I have recently discovered that it's possible for me to spend an hour or two a day playing Stardew Valley, so I can swap some of that time for Emacs tweaking instead. Coding doesn't handle interruptions as well as playing does, but taking notes along the way might be able to help with that. I can jump to the section of my Org file with the ideas I wanted to save for more focus time, pick something from that screen, and get right to it.

Other things that might help me do this more effectively would be:

  • getting better at using my tools (debugger, documentation, completion, etc.),
  • taking the opportunity to plug in an external monitor, and
  • using my non-computer time to mull over the ideas so that I can hit the ground running.

I like taking notes at virtual meetups. I usually do this with Etherpad so that other people can contribute to the notes too. I don't have a real-time read-write Emacs interface to this yet (that would be way cool!), but I do have some functions for working with the Etherpad text.

Life reflections

When I notice something I want to figure out or remember, I use sketches, audio braindumps, or typing to start to untangle that thought. Sometimes I use all three, shifting from one tool to another depending on what I can do at the moment. I have a pretty comfortable workflow for converting sketches (Google Vision) or audio (OpenAI Whisper) to text so that I can work with it more easily, and I'm sure that will get even smoother as the technology improves. I switch from one tool to another as I figure out the shape of my thoughts.

Maybe I can use microblogging to let smaller ideas out into the world, just in case conversations build them up into more interesting ideas. I don't quite trust my ability to manage my GoToSocial instance yet (backups? upgrades?), so that might be a good reason to use a weekly or monthly review to revisit and archive those posts in plain text.

I've been reading my on this day list of blog posts and sketches more regularly now that it's in my feed reader. I like the way this helps me revisit old thoughts, and I've saved a few that I want to follow up on. It feels good to build on a thought over time.

I'd like to do more of this remembering and thinking out loud because memories are fleeting. Maybe developing more trust in my private journals and files will help. (Gotta have those backups!) Then I'll be more comfortable writing about the things we're figuring out about life while also respecting A+ and W-'s privacy, and I can post the stuff I'm figuring out about my life that I'm okay with sharing. I might think something is straightforward, like A+'s progress in learning how to swim. I want to write about how that's a microcosm of how she's learning how to learn more independently and my changing role in supporting her. Still, she might have other opinions about my sharing that, either now or later on. I can still reflect on it and keep that in a private journal as we figure things out together.

Even though parenting takes up most of my time and attention at the moment, it will eventually take less. There are plenty of things for me to learn about and share outside parenting, like biking, gardening, and sewing. I've got books to read and ideas to try out.

I'm experimenting with doing more writing on my phone so that I can get better at using these little bits of time. Swiping letters on a keyboard is reasonably fast, and the bottleneck is my thinking time anyway. I use Orgzly Revived so that Syncthing can synchronize it with my Org Mode files on my laptop when I get back home. There are occasional conflicts, but since I mostly add to an inbox.org when I'm on my phone, the conflicts are usually easy to resolve.

Adding doodles to my reflections can make them more fun. I can draw stick figures from scratch, and I can also trace my photos using the iPad as a way to add visual anchors and practise drawing. If I get the hang of using a smaller portion of my screen like the way I used to draw index cards, that might make thoughts more granular and easier to complete.

When I write on my computer, I often use writeroom-mode so that things feel less cluttered. I like having big margins and short lines. I have hl-line-mode turned on to help me focus on the current paragraph. This seems to work reasonably well.

2025-07-26_00-33-44.png
Figure 1: Screenshot showing writeroom-mode and hl-line-mode

Monthly and yearly reviews

I like the rhythm of drawing daily moments and keeping a web-based journal of brief descriptions of our day. I like how I've been digging into them deeper to reflect on themes. The monthly drawings and posts make it easier to review a whole year. Maybe someday I'll get back to weekly reviews as well, but for now, this is working fine.

My journal entries do a decent job of capturing the facts of our days: where we went, what we did. Maybe spending more time writing life reflections can help me capture more of what goes on in my head and what I want to learn more about.

Book notes

I draw single-page summaries of books I like because they're easier to remember and share. E-books are convenient because I can highlight text and extract that data even after I've returned the book, but I can also retype things from paper books or use the text recognition feature on my phone camera. I draw the summaries on my iPad using Noteful, and then I run it through my Google Vision workflow to convert the text from it so that I can include it in a blog post.

The main limiting factor here is my patience in reading a book. There are so many other wonderful things to explore, and sometimes it feels like books have a bit of filler. When I have a clear topic I'm curious about or a well-written book to enjoy, it's easier to study a book and make notes.

Emacs workflow thoughts

Aside from considering the different types of writing I do, I've also been thinking about the mechanics of writing in Emacs. Sanding down the rough parts of my workflow makes writing more enjoyable, and sometimes a small tweak lets me squeeze more writing into fragments of time.

There are more commands I want to call than there are keyboard shortcuts I can remember. I tend to use M-x to call commands by name a lot, and it really helps to have some kind of completion (I use vertico) and orderless matching.

I'm experimenting with more voice input because that lets me braindump ideas quickly on my phone. Long dictation sessions are a little difficult to edit. Maybe shorter snippets using the voice input mode on the phone keyboard will let me flesh out parts of my outline. I wonder if the same kind of quick input might be handy on my computer. I'm trying out whisper.el with my Bluetooth earbuds. Dictating tends to be stop-and-go, since I feel self-conscious about dictating when other people are around and I probably only have solo time late at night.

Misrecognized words can be annoying to correct on my phone. They're much easier to fix on my computer. Some corrections are pretty common, like changing Emax to Emacs. I wrote some code for fixing common errors (my-subed-fix-common-errors), but I don't use this often enough to have it in my muscle memory. I probably need to tweak this so that it's a bit more interactive and trustworthy.

When I see a word I want to change, I jump to it with C-s (isearch-forward) or C-r (isearch-backward), or I navigate to it with M-f (forward-word). I want to get the hang of using Avy because of Karthik's awesome post about it. That post is from 2021 and I still haven't gotten used to it. I probably just need deliberate practice using the shortcut I've mapped to M-j (avy-goto-char-timer). Or maybe I just don't do this kind of navigation enough yet to justify this micro-optimization (no matter how neat it could be), and isearch is fine for now.

Sometimes I want to work with sentences. expand-region is another thing I want to get used to. I've bound C-= to er/expand-region from that package. Then I should be able to easily kill the text and type a replacement or move things around. In the meantime, I can usually remember to use my keyboard shortcut of M-z for avy-zap-up-to-char-dwim for deleting something.

Even in vanilla Emacs, there's so much that I think I'll enjoy getting the hang of. oantolin's post on his writing experience helped me learn about M-E, which marks the region from the point to the end of the sentence and is a natural extension from M-e. Similarly, M-F selects the next word. I could use this kind of shift-selection more. I occasionally remember to transpose words with M-t, but I've been cutting and pasting sentences when I could've been using transpose-sentences all this time. I'm going to add (keymap-global-set "M-T" #'transpose-sentences) to my config and see if I remember it.

I like using Org Mode headings to collapse long text into a quick overview so I can see the big picture, and they're also handy for making tables of contents. It might be neat to have one more level of overview below that, maybe displaying only the first line of each paragraph. In the meantime, I can use toggle-truncate-lines to get that sort of view.

If I'm having a hard time fitting the whole shape of a thought into my working memory, I sometimes find it easier to work with plain list outlines that go all the way down to sentences instead of working with paragraphs. I can expand/collapse items and move them around easily using Org's commands for list items. In addition, org-toggle-item toggles between items and plain text, and org-toggle-heading can turn items into headings.

I could probably write a command that toggles a whole section between an outline and a collection of paragraphs. The outline would be a plain list with two levels. The top level items would be the starting sentences of each paragraph, and each sentence after that would be a list item underneath it. Sometimes I use actual lists. Maybe those would be a third level. Then I can use Org Mode's handy list management commands even when a draft is further along. Alternatively, maybe I can use M-S-left and M-S-right to move sentences around in a paragraph.

Sometimes I write something and then change my mind about including it. Right now, I tend to either use org-capture to save it or put it under a heading and then refile it to my Scraps subtree, but the palimpsest approach might be interesting. Maybe a shortcut to stash the current paragraph somewhere…

I use custom Org link types to make it easier to link to topics, project files, parts of my Emacs configuration, blog posts, sketches, videos, and more. It's handy to have completion, and I can define how I want them to be exported or followed.

Custom Org link types also let me use Embark for context-sensitive actions. For example, I have a command for adding categories to a blog post when my cursor is on a link to the post, which is handy when I've made a list of matching posts. Embark is also convenient for doing things from other commands. It's nice being able to use C-. i to insert whatever's in the minibuffer, so I can use that from C-h f (describe-function), C-h v (describe-variable), or other commands.

I also define custom Org block types using org-special-block-extras. This lets me easily make things like collapsible sections with summaries.

I want to get better at diagrams and charts using things like graphviz, mermaidjs, matplotlib, and seaborn. I usually end up searching for an example I can build on and then try to tweak it. Sometimes I just draw something on my iPad and stick it in. It's fine. I think it would be good to learn computer-based diagramming and charting, though. They can be easier to update and re-layout when I realize I've forgotten to add something to the graph.

Figuring out the proper syntax for diagrams and charts might be one of the reasonable use cases for large-language models, actually. I'm on the fence about LLMs in general. I sometimes use claude.ai for dealing with the occasional tip of the tongue situation like "What's a word or phrase that describes…" and for catching when I've forgotten to finish a sentence. I don't think I can get it to think or write like me yet. Besides, I like doing the thinking and writing.

I love reading about other people's workflows. If they share their code, that's fantastic, but even descriptions of ideas are fine. I learn so many things from the blog posts I come across on Planet Emacslife in the process of putting together Emacs News. I also periodically go through documentation like the Org Mode manual or release notes, and I always learn something new each time.

This post was really hard to write! I keep thinking of things I want to start tweaking. I treat Emacs-tweaking as a fun hobby that sometimes happens to make things better for me or for other people, so it's okay to capture lots of ideas to explore later on. Sometimes something is just a quick 5-minute hack. Sometimes I end up delving into the source code, which is easy to do because hey, it's Emacs. It's comforting and inspiring to be surrounded by all this parenthetical evidence of other people's thinking about their workflows.

Each type of writing helps me with a different type of thinking, and each config tweak makes thoughts flow more smoothly. I'm looking forward to learning how to think better, one note at a time.

Check out the Emacs Carnival July theme: writing experience post for more Emacs ideas. Thanks to Greg Newman for hosting!

View org source for this post

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

-1:-- My Emacs writing experience (Post Sacha Chua)--L0--C0--2025-07-26T04:10:58.000Z

Alvaro Ramirez: macOS dictation returns to Emacs (fix merged)

macOS apps typically benefit from built-in voice dictation input (included as a macOS freebie), with little to no additional work required from app developers.

Emacs had supported this capability until relatively recently, when we began seeing reports that dictation was no longer available as of Emacs 30.

While I have no direct experience with macOS dictation-related APIs, I bisected Emacs 30 changes affecting macOS-related code (typically Objective-C code with .m file extensions). This led me to a seemingly harmless change introducing NSTextInputClient, intended to remove a deprecation warning. From that change onwards, dictation stopped working.

Reverting the change did indeed bring dictation back, but at the cost of re-introducing the deprecation warning. Looking closer at the current NSTextInputClient implementation, I noticed some stubbed-out methods. In particular, selectedRange stood out:

- (NSRange)selectedRange
{
  if (NS_KEYLOG)
    NSLog (@"selectedRange request");
  return NSMakeRange (NSNotFound, 0);
}

Turns out implementing selectedRange is all it took to bring dictation back:

diff --git a/src/nsterm.m b/src/nsterm.m
index 003aadb9782..2b34894f36e 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -7413,7 +7413,24 @@ - (NSRange)selectedRange
 {
   if (NS_KEYLOG)
     NSLog (@"selectedRange request");
-  return NSMakeRange (NSNotFound, 0);
+
+  struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (emacsframe));
+  struct buffer *buf = XBUFFER (w->contents);
+  ptrdiff_t point = BUF_PT (buf);
+
+  if (NILP (BVAR (buf, mark_active)))
+    {
+      NSUInteger selection_location = point - BUF_BEGV (buf);
+      return NSMakeRange (selection_location, 0);
+    }
+
+  ptrdiff_t mark = marker_position (BVAR (buf, mark));
+  ptrdiff_t region_start = min (point, mark);
+  ptrdiff_t region_end = max (point, mark);
+  NSUInteger selection_location = region_start - BUF_BEGV (buf);
+  NSUInteger selection_length = region_end - region_start;
+
+  return NSMakeRange (selection_location, selection_length);
 }

Implementing selectedRange didn't just bring dictation back, but now leverages a newer macOS dictation implementation. You can see the slight differences in UI.

Before

After

Merged upstream

I've since submitted a patch upstream. I'm happy to report that as of today, the patch is now merged into master. Thank you Gerd Möllmann and Eli Zaretskii for your help! Also big thanks to Stephen Englen, Fritz Grabo, @veer66 and @dotemacs on the fediverse who quickly jumped in to help validate the fix.

While we've yet to find out when the next Emacs release will ship, we at least know the fix is coming! If like me, you'd like to get the fix backported to Emacs 30, I've shown you how to do just that on Emacs Plus (my favourite macOS build).

Make it all sustainable

Glad macOS dictation is fixed? Enjoying this blog or my projects? I am an 👉 indie dev 👈. Help make my work sustainable by ✨sponsoring

Need a blog? I can help with that. Maybe buy my macOS/iOS apps too ;)

-1:-- macOS dictation returns to Emacs (fix merged) (Post Alvaro Ramirez)--L0--C0--2025-07-26T00:00:00.000Z

Protesilaos Stavrou: Prot Asks: Ihor about maintaining Emacs Org mode, history, travels, and material science

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

In this new video series, I talk to anybody who is interested to have a video call with me (so do contact me if you want!). The topics cover anything related to Emacs, technology, and life in general. More information in the announcement I posted: https://protesilaos.com/codelog/2025-07-10-prot-asks-chats-videos-proposal/.

Today I learnt from Ihor Radchenko what kind of work goes into maintaining the Emacs Org package. We discussed the process of contributing to Org and how the community is involved in the process. Other than the technicalities of Emacs, I asked Ihor about general interests in life. Some of those involve the study of history, which we explored in some further depth. Ihor has travelled and worked in various parts of the planet. I wanted to understand more about those experiences. Towards the end of our meeting, I wanted to gain insights into what “material science” is in practice.

From Ihor

  • Emacs browsers
    • https://protesilaos.com/codelog/2021-03-25-emacs-eww/
    • https://github.com/manateelazycat/emacs-application-framework
    • https://github.com/qutebrowser/qutebrowser/
      • my config: https://github.com/yantar92/emacs-config/blob/master/system-config.org#qutebrowser-1
  • Key bindings
    • https://github.com/jyp/boon
      • my config: https://github.com/yantar92/emacs-config/blob/master/config.org#key-bindings
  • My talk, where I describe a bit more about how I got to maintain Org mode
    • https://emacsconf.org/2024/talks/org-update/
  • On making first contribution easier: https://orgmode.org/worg/org-contribute.html#org2bb8d25
  • My email setup to recognize first-time mailing list participants and first-time contributors
    • https://github.com/yantar92/emacs-config/blob/master/config.org#detect-fsf-contribution-status-of-sender-for-org-ml
  • Philosophy about being friendly to the newcomers https://orgmode.org/worg/org-maintenance.html#org18cc771
  • Guix migration away from email-based workflow to codeberg
    • https://guix.gnu.org/blog/2025/migrating-to-codeberg/
  • web page about org-element API
    • https://orgmode.org/worg/dev/org-element-api.html
    • Section of the manual linking to that page: https://orgmode.org/manual/Advanced-Export-Configuration.html
  • org-ml library: https://github.com/ndwarshuis/org-ml
  • meditation (Autogenic training)
    • https://en.wikipedia.org/wiki/Autogenic_training#Applications
  • Textbook on finance I am reading: Modern Portfolio Theory and Investment Analysis, 9th Edition
    • https://www.wiley.com/en-us/Modern+Portfolio+Theory+and+Investment+Analysis%2C+9th+Edition-p-9781118469941
  • EDX course on animal husbandry
    • The actual course is no longer available online, but https://learning.edx.org/course/course-v1:WageningenX+ABG02x+2T2025/home is similar
  • Greek philosophy
    • https://historyofphilosophy.net/series/classical-greek-philosophy
  • Bronze Age collapse https://www.youtube.com/watch?v=B965f8AcNbw https://www.youtube.com/watch?v=bRcu-ysocX4
  • The Cambridge history of ancient China : from the origins of civilization to 221 B.C. https://archive.org/details/cambridgehistory0000unse_i9g4
  • pottery village near Xi’an (陈炉): https://www.bilibili.com/video/BV1ce4y1Q7MX/
  • On different cultures in China
    • https://www.bilibili.com/video/BV13f4y1Q7qa?p=2&spm_id_from=333.788.videopod.episodes
    • https://en.wikipedia.org/wiki/Sanxingdui https://www.youtube.com/watch?v=teCKq6AJtP8
  • On China/Greece contacts https://www.history.com/articles/greeks-may-have-influenced-chinas-terra-cotta-army (I also recall one of the excavated tombs in Xi’an having western person buried) https://www.youtube.com/watch?v=J-pfeFbssMw
  • Heixi corridor
    • https://www.youtube.com/watch?v=OZH9IBGnoNU&list=PL_gSHsLUsq9GYtGHstai8yY4R5cSNjvGn&index=10
    • https://en.wikipedia.org/wiki/Hexi_Corridor
  • Dunhuang https://en.wikipedia.org/wiki/Dunhuang
    • The caves: Mogao caves https://en.wikipedia.org/wiki/Mogao_Caves https://www.youtube.com/watch?v=–XM0cES6Sg 3d virtual museum: https://www.e-dunhuang.com/index.htm
  • Singapore https://www.youtube.com/watch?v=-wwW3wLNFAY&t=341s
  • Manila https://www.youtube.com/watch?v=Ra6ztNcUlsY (slums) https://www.youtube.com/watch?v=8w-X-NU-p9U (the rest)
  • Taiwan
    • trains: https://www.youtube.com/watch?v=ogv4jIz9H3w
    • the actual place I went to: https://www.youtube.com/watch?v=1FWymGGdKrI
  • Zakopane, Poland
    • https://www.youtube.com/watch?v=bfEJDvPxGtA
  • Mountains in Xi’an: https://www.youtube.com/watch?v=GkHR9GQGcfA https://www.youtube.com/watch?v=b7lAFBbaMpg
  • Mountains in the south of China (known from classical paintings) https://www.youtube.com/watch?v=MIWXK7fPRTY (not exactly what I was talking about, but gives an idea)
    • Similar in Greece (Meteora)
      • https://wikitravel.org/en/Meteora
      • https://www.youtube.com/watch?v=OF4o5u-kYTw
  • And hanging temple in China https://www.youtube.com/watch?v=xZTtILl-xpE
  • Ancient Chinese irrigation projects
    • https://www.youtube.com/watch?v=4KvvnJa1d5Y (Chengdu, dam)
    • https://www.youtube.com/watch?v=-O19SeNqauA (canal - through half of China)
  • Reinforced concrete https://www.youtube.com/watch?v=JHuf1Hu7ApU
  • On carbon fiber composites for airplanes
    • https://www.youtube.com/watch?v=STRidcDx47I
  • On research funding
    • https://www.youtube.com/watch?v=6sBeKHyiV6c
    • these days, there is generally more focus on concrete outcomes of research (de facto, even what called “basic research” on paper)
  • On sodium-ion (table salt) batteries
    • https://www.youtube.com/watch?v=RQE56ksVBB4 (video is 2 years old; now there are many more companies)
  • Li-ion (super-expensive) super storage to capture solar/wind power during the day and provide energy during night (simply speaking)
    • https://en.wikipedia.org/wiki/Hornsdale_Power_Reserve
  • Example of basic science to understand human behavior https://www.youtube.com/watch?v=NNnIGh9g6fA&list=PL150326949691B199
-1:-- Prot Asks: Ihor about maintaining Emacs Org mode, history, travels, and material science (Post Protesilaos Stavrou)--L0--C0--2025-07-26T00:00:00.000Z

Amin Bandali: Mirroring Protesilaos' videos to Internet Archive

I enjoy reading and watching the writings and videos that Protesilaos publishes on his website, with his work ranging from philosophy and various life issues to GNU Emacs and programming. Currently, Prot uploads his videos to YouTube and embeds them on his website. YouTube, diligently working their way down the spiral of enshittification, have been making it increasingly difficult to watch the videos without using their nonfree JavaScript interface or their nonfree mobile applications. This got me thinking about mirroring Prot’s videos to the Internet Archive to make them more easily accessible in freedom.

To mirror all of Prot’s videos to the Internet Archive is a nontrivial task: as of the time of this writing, there are a total of 298 videos uploaded to Prot’s YouTube channel. Thankfully, Prot makes publicly available the git repository containing the sources used to build his website, and we have several excellent tools at our disposal to help extract the information we need and carry this out.

Note: Prot publishes his works under free/libre copyleft licenses like CC BY-SA 4.0 and GPLv3+, so we do not violate his copyright by sharing or redistributing his work so long as we do it with proper credit, following the terms of the licenses.

The idea is to write a program that would walk through the set of markdown files in the source repository for Prot’s website and for each file that has a mediaid metadata field, download the video with that ID from YouTube using yt-dlp, and upload it along with accompanying metadata to the Internet Archive using the internetarchive Python module. Given that these two key tools are written in Python, I opted to use Python for my own implementation as well. (I initially started the implementation as a POSIX shell script, but then decided that I would like the convenience of a ‘proper programming language’ and being able to interact with these tools through their respective API, so I ported what I had to Python and continued there.)

The full implementation is available at protesilaos_videos_archive.py. Note that some of the required modules are not part of Python’s standard library, namely markdown, yt-dlp, and internetarchive. You can install these using your distribution’s package manager or using pip, the Python package manager.

The script takes several command line arguments. There is a required positional argument for specifying the directory to search through (recursively) for markdown files. Normally, this would be the path to your local copy of the source repository for Prot’s website. There are also two --cookie-file and --working-dir options for optionally specifying the path to a cookie file for use with yt-dlp and the working directory for storing the downloaded videos and the progress file, respectively. Considering YouTube’s somewhat aggressive rate-limiting of IPs, if you will be downloading a nontrivial number of videos, you will probably want to use --cookie-file to specify the file that contains cookies from a YouTube session. (You would log into YouTube using your account, then use an add-on like cookies.txt to extract and save your session’s cookies into a text file.)

Example invocation of the program:

./protesilaos_videos_archive.py --cookie-file=cf.txt ~/src/protesilaos.gitlab.io

Also, considering the large number of videos to be downloaded and uploaded, making this a long-running task, I thought it would be helpful to allow interrupting the work partway through by stopping the program by pressing Ctrl-c in the terminal to send a SIGINT. Upon receiving a SIGINT, the program will stop the work after the current download or upload is finished, and write the progress to a progress file, .pva-progress.jsonl, which it will use on the next run to resume the work where it was left off.

As of the time of this writing, all of the videos published by Prot on his YouTube channel have been mirrored to the Internet Archive, and are available from the Video Publications by Protesilaos Stavrou collection.

I’ll wrap up by thanking Prot for clarifying the license of his video publications and for his blessing for me to mirror them on the Internet Archive. Thanks, Prot. :)

Take care, and so long for now.

P.S. yt-dlp has a --write-description option, which causes it to write a .description file along with the downloaded video containing its description text from YouTube. I still opted to go with the above approach of using each post’s body text as ‘description’ in part because the markdown source file for each video post contains more metadata fields that I was planning on uploading to the Archive anyway.

-1:-- Mirroring Protesilaos' videos to Internet Archive (Post Amin Bandali)--L0--C0--2025-07-25T18:02:37.000Z

Alvaro Ramirez: Writing experience: My decade with Org

While I missed Emacs Carnival's Take two, with this month's prompt being Writing Experience, I figured I may have a thing or two to share about my Org adoption.

Org mode is often regarded as one of the indispensable Emacs features. A Swiss army of sorts enabling outlining, presentations, task management, agenda, note-taking, blogging, literate programming, the list goes on… At its core, Org features are powered by a versatile markup. Kinda like Markdown but on steroids. When starting with Org, it's easy to feel lost in the overwhelming sea of features.

Luckily, we don't have to know or understand all of Org to get started nor ever need to. You get to pick and use what's useful to you at any given time.

Getting started

Want to get started with outlines? Easy. Let's say you wanted to start collecting python idioms, you can start with an entry like:

* Python idioms

- Prefer double quotes if escaping single quotes.
- Prefer string interpolation over join. Eg. "'%s'" % member_default.

...

That's precisely what I did when I started using Org nearly 12 years ago. I created a notes file and added my first entry to collect python 2 idioms. While the idioms may be outdated by now (who knows, it's been many years since I've written any significant amount of python code), but hey that's besides the point. I wanted to start a personal notes file and Org sounded awesome for that.

Over time, my notes file grew in usefulness. The more I wrote, the more I could recall with search. That is, until I was away from my computer. At that point, I figured I could just export my notes to HTML (via M-x org-export-dispatch) and post online. Over time, folks started reaching out about something read in my notes, and so by then I suppose I had accidentally become a blogger.

Blogging

In 12 years of "blogging", my approach hasn't changed much. I still write to the very same Org file (beware it's big) I started writing notes to. I found this approach fairly accessible, with little ceremony. When I want to write, I open the usual text file and just write. It wasn't until fairly recently I learned this is often referred to as "one big text file" (OBTF).

My HTML exporting evolved into hacky elisp cobbled together over time. While the code was nothing to rave about, it did the job just fine for well over a decade. Having said that, it was more of an "it works on my machine" sorta thing. Last year, I finally decided to change my blogging approach and built a blogging platform (in 2024?! I know right?!). Well, the modern web has led us to a sea of tracking, bloat, advertising, the list goes on… I wanted to offer a lightweight blogging alternative with none of the typical crummy bits, so I built LMNO.lol. Today, my xenodium.com blog runs off that.

Org and Markdown are friends

LMNO.lol is powered by Markdown. Wait, what? You may be wondering why an Org fan would build a blogging platform powered by a different markup? In a nutshell, reach. While I remain a faithful Org fan for its capabilities, if I want my blogging platform to appeal to more users, I can't ignore the fact that today Markdown is the prevalent format. Having said that, I wasn't about to give up on Org for personal use. I can actually have my cake and eat it too. You see, I continue writing to Org and convert to Markdown before uploading to LMNO.lol via pandoc, the Swiss Army tool of file converters.

Incremental Org adoption

Tables

As you know, my Org adoption started with a very simple outline intended for personal notes, but we know Org is a universe of its own. I soon learned about Org tables.

| name                 | job              | origin             |
|----------------------+------------------+--------------------|
| Fry                  | Delivery Boy     | Earth              |
| Bender               | Bending Unit     | Earth              |
| Leela                | Captain          | Mutant Underground |
| Professor Farnsworth | Scientist        | Earth              |
| Amy Wong             | Intern           | Mars               |
| Dr. Zoidberg         | Staff Doctor     | Decapod 10         |
| Hermes Conrad        | Bureaucrat       | Earth              |
| Zapp Brannigan       | 25-Star General  | Earth              |
| Mom                  | Owner of MomCorp | Earth              |
| Nibbler              | Leela's pet      | Planet Eternium    |

I'd keep finding really handy Org tips here and there. Like converting csv to Org by merely selecting the text from my beloved editor.

Tasks

We mentioned Org handling task management, amongst many other things. In a nutshell, tasks in Org are "simple TODO lists", using special keywords. I got started with Org tasks with something like this:

* DONE Call granny
* DONE Post on Reddit
* STARTED Procrastinate some more
* TODO Do your homework

I say "simple TODO lists" (in quotes) because Org task management is a another universe of its own. You can schedule tasks in all sorts of ways (like recurring), as habits, tag them, refile them, etc. and even get a nice agenda view to interact with.

I don’t have an agenda post on this myself, but Christian Tietze has a wonderful write-up showcasing an improved Org-mode agenda display.

Babel

Moving on from task management, I soon discovered babel, another Org super power enabling you to include code snippets. Not too different to Markdown, but I found the ability to evaluate/execute snippets and capture output pretty magical.

#+BEGIN_SRC python
  print("Hello python world")
#+END_SRC

#+RESULTS:
: Hello python world

Adding Objective-C Org babel support

At the time, I was writing a fair bit of Objective-C code but found babel support was missing. By looking at ob-C.el and ob-java.el, I figured how to add Objective-C support. Surprisingly, it took very little code and I could now execute Objective-C code just like python from the comfort of an Org buffer.

#+BEGIN_SRC objc
  #import <Foundation/Foundation.h>

  int main() {
    NSLog(@"Hello ObjC World");
    return 0;
  }
#+END_SRC

#+RESULTS:
: Hello ObjC World

Adding Org block completion

With Org code blocks (and babel superpowers), I soon found myself including lots of snippets in my notes. I tried different different input mechanisms and eventually settled on writing my own company completion backend.

company-org-block is available on GitHub and MELPA.

Later on, with Michael Eliachevitch's help, we got org-block-capf going.

Fitbit API, Org babel, and gnuplot

I continued having fun with Org babel. You can combine source blocks for different purposes, so I used it to fetch and plot Fitbit data via Gnuplot.

#+BEGIN_SRC sh :results table
curl -s -H "Authorization: Bearer TOKEN" https://api.fitbit.com/1/user/USER_ID/body/weight/date/2018-06-09/2018-07-11.json | jq '.[][] | "\(.dateTime) \(.value)"' | sed 's/"//g'
#+END_SRC

#+RESULTS: weight-data
| 2018-06-09 | 65.753 |
| 2018-06-10 | 65.762 |
...
| 2018-07-10 |  64.22 |
| 2018-07-11 |  63.95 |

#+BEGIN_SRC gnuplot :var data=weight-data :exports code :file images/fitbit-api-org-babel-and-gnuplot/weight.png
reset
set title "My recent weight"
set xdata time
set timefmt '%Y-%m-%d'
set format x "%d/%m/%y"
set term png
set xrange ['2018-06-09':'2018-07-11']
plot data u 1:2 with linespoints title 'Weight in Kg'
#+END_SRC

Adding SwiftUI Org babel support

Having learned that babel can generate images (like Gnuplot), I figured I could have fun with SwiftUI too and built ob-swiftui. Also on MELPA.

Adding Org links (DWIM style)

Notes aren't complete without links to references. I was already using a keyboard shortcut of sorts, but I figured I could make it much smarter. As in DWIM: Do what I mean. Like automatically fetching link title from the web and other things.

Scraping useful links

Comments in posts can be a great source of recommendations (someone asking for books, blogs, etc), so I figured I could get Emacs to extract all links from an online post and dump them to an org file.

Change your MAC address in Org of course

Cause you never know when you're gonna need it, I randomly saved a snippet to change your MAC address from the comfort of your Org notes. Execute via C-c C-c.

#+begin_src bash :dir /sudo::
  changeMAC() {
      local mac=$(openssl rand -hex 6 | sed 's/\(..\)/\1:/g; s/.$//')
      ifconfig en0 ether $mac
      ifconfig en0 down
      ifconfig en0 up
      echo "Your new physical address is $mac"
  }

  changeMAC
#+end_src

#+RESULTS:
: Your new physical address is b4:b2:f8:77:bb:87

By the way, noticed the :dir /sudo:: header? It enables executing the snippet as root.

Generating documentation for your Emacs package

Having built a handful of Emacs packages, maintaining a README.org documenting commands available (and keeping it up-to-date) was a bit of a chore. I figured you could automate things and generate a nice Org table documenting your package commands and customizable variables.

When you see this table in my GitHub project, you now know how it was generated.

A noweb detour: the lesser known Org babel glue

While Org babel's noweb support isn't super widely known, I learned it's great for glueing org babel blocks. I love how Org knowledge (and Emacs benefits really) just keep compounding. I started by just writing a simple Org outline. Remember?

LLMs join the babel chat

In 2023, I started experimenting with LLMs and Emacs integrations. Naturally, I had to add babel support too, so ob-chatgpt-shell (MELPA) and ob-dall-e-shell (MELPA) were added to the mix.

Smarter Org capture templates

Your knowledge base is only as useful as its wealth. The more you write, the better. And of course, the less friction, the more likely you are to write more.

Org capture is super useful to save your thoughts quickly into an Org file. You can come up with all sorts of templates to expedite the process. In addition to the base structure, I figured I could automatically capture my current location, date, time, and weather as part of a note.

Presenting in style

There are no shortages of Emacs packages leveraging Org mode to give presentations (org-present is one of many). I often enjoy David Wilson's videos. In this one, he shares his presentation setup. I figured it'd be fun to experiment with org-present to spiff things up. I wanted a sort of smart navigation where items are automatically expanded and collapsed as I <tab> my way through a presentation.

Org as lingua franca

With my Org usage growing, I felt like I was missing Org support outside of Emacs. Web access to my blog wasn't enough. I wanted to quickly capture things while on the go, so I started building iOS apps revolving around my Emacs and Org usage.

Journelly (iOS)

Journelly is my latest iOS app, centered around note-taking and journaling. The app feels like tweeting, but for your eyes only of course. It's powered by Org markup, which can be synced with Emacs via iCloud.

Flat Habits (iOS)

Org habits are handy for tracking daily habits. However, it wasn't super practical for me as I often wanted to check things off while on the go (away from Emacs). That led me to build Flat Habits.

Scratch (iOS)

While these days I'm using Journelly to jot down just about anything, before that, I built and used Scratch as scratch pad of sorts. No iCloud syncing, but needless to say, it's also powered by Org markup.

Plain Org (iOS)

For more involved writing, nothing beats Emacs Org mode. But what if I want quick access to my Org files while on the go? Plain Org is my iOS solution for that.

LMNO.lol

While I already mentioned LMNO.lol, it's been heavily inspired by my Org workflow. You write your notes or blog posts to a single plain text file, sprinkling Markdown this time around, and just drag and drop it to the web. LMNO.lol takes care of the rest.

Org bookmarks

While there is newer content out there, I did capture a handful of Org bookmarks at some point. This one took me down memory lane. Sacha Chua used make these really fun videos interviewing Emacs folks, often discussing their Emacs configs. I learned a ton from these videos. That time, Sacha interviewed Howard Abrams. Gosh, that was over 10 years ago.

Off the top of my head, Karl Voit also comes to mind, for championing Org for years. I know I'm not doing it justice. There are far too many folks I've learned from, who kindly share their knowledge. I've bookmarked some of them in the past.

Naturally, my Org journey wouldn't be possible without Org mode itself and the incredible work from the authors and maintainers. I've personally donated to their cause and even got my ex-employer to donate multiple times.

I could keep showing more things…

You could argue my Org usage is fairly random. Maybe it is. I'd say it's more organic than anything. I more or less started writing outlines and TODO lists, incrementally adopting whatever needed over time. It's up to you how much or little Org you adopt. Whatever you pick is the right answer for you. The Org feature set is just so vast. Some of the things I've tried didn't stick for me like plotting ledger reports or combating spam through Org, but by trying things I got to discover other things that probably did stick.

I could keep going, showing you more examples of the things I discovered, but in such a vast universe what's useful to me may not be useful to you. With such a diverse toolbox, it's highly likely you'll find just the right tool for your needs.

Ok, we get it. The feature set is rich. But most importantly, your data is saved in plain, transparent text, easily accessible to other tools. Heck, I even wrote my own iOS apps to view and edit Org files on the go. In over ten years of using Org, I've never lost access to my data, and I never will. That alone is the non-negotiable cherry on the cake.

Make it all sustainable

Learned something new? Enjoying this blog or my projects? I am an 👉 indie dev 👈. Help make it sustainable by ✨sponsoring

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

-1:-- Writing experience: My decade with Org (Post Alvaro Ramirez)--L0--C0--2025-07-25T00:00:00.000Z

Please note that planet.emacslife.com aggregates blogs, and blog authors might mention or link to nonfree things. To add a feed to this page, please e-mail the RSS or ATOM feed URL to sacha@sachachua.com . Thank you!