TAONAW - Emacs and Org Mode: Dired: Classic Technique for Manual-Visual Search

Here’s a Dired thing that most Emacs veterans know well, but only clicked for me yesterday: searching for specific words and terms in different files while narrowing the results down until you find exactly what you need.

There are many ways to do this, some in Emacs and some outside, but I find that the manual-visual process in the middle makes this especially powerful, as you get to see the files selected each time and decide what to keep as you keep narrowing down your search.

Let’s say you want to find journal entries where you wrote about a vacation that involved going out of state, and maybe get an idea of where you stayed, say a hotel vs. an Airbnb.

  1. In Dired, go to the folder where the words are (say your journal notes directory) and enter % g for a regex search for term 1 — in our case, “vacation”.
  2. Dired will mark the files containing “vacation” somewhere in the text.
  3. You now start the manual narrowing process:
    1. Enter t to mark all the opposite files, the ones that were not included in the results before. What you have now are all the files that do not have the word “vacation” in them.
    2. Enter k to remove the marked lines from view (don’t worry, this just hides the files. They are still there, just hit g). You now have the files you don’t need — those that do not have the word “vacation” in them — out of the way.
  4. You can now go back to step 1, running another search on those narrowed results. In our example, enter % g again for term 2 — “airport” (maybe you drive, but you get the idea) — and narrow again. Because we are now only working with the files that remained after our first round of narrowing, these files (by deductive logic of what we did) now contain the word “vacation” already. The files we are now narrowing (steps 3.1 and 3.2) will contain the word “vacation” and the word “airport”. When you’re done narrowing a second time and have the files that contain “vacation” and “airport”:
  5. Mark all the files you have left (or the one you decide you want from what’s left, looking at the list of files), and enter A1. This works on the file at point unless you have a couple marked, so that’s why we need to mark those first. This runs a fresh regex search over the full contents of the marked files, and will show the results in a dedicated buffer, so you see all the results from all the files in a list, showing you which file they are from and on what lines you can find them. Since this is a regex search, you can get fancy here. For me, I found that at this point the selection is small enough to find what I need: I can run one search for “hotel”, another for “Airbnb”, no problem.

As I said above, there are many ways to run something automatic and not go through these steps, but the fact that you see the files in front of you is powerful.

For example, in step 5, when you look at what you have left, you might find an old packing list template that somehow snuck into your journal folder (this never happens to me though! I’m way too organized… uhm…), or maybe you have an idea of what time of year you went on a particular vacation you’re looking for (say if it was a vacation during the summer), so you can manually take out files that contain the above words but have a timestamp of December and February.


  1. A runs the command dired-do-find-regexp, for searching, so it’s worth noting that in Dired it has a sibling: Q for dired-do-find-regexp-and-replace, which replaces the searched term with your choice. Great for fixing a mistake you may have in a couple of files, like a misspelled name you keep getting wrong. ↩︎

-1:-- Dired: Classic Technique for Manual-Visual Search (Post TAONAW - Emacs and Org Mode)--L0--C0--2026-11-20T15:06:23.000Z

Mickey Petersen: Announcing DreamCoder

It’s been a little bit quiet around these parts; sorry about that. I’ve been really busy for the past fifteen months with a major project that I am finally ready to formally release. So I’d like to talk about that project, and also a potted history of AI and Emacs.

It’s called DreamCoder, an AI coding harness that is very different from the ones you’re probably familiar with already.

I installed Claude Code a few days after its first release some time in May 2025. I put some coins in the slot machine and I put it to work building a complex piece of enterprise middleware I’d built several times in my career. Wow.. watching this thing chomp its way through the project with that chaotic, early Sonnet energy. It was far, far from perfect; it required a lot of human steering, input and correction, but the speed advantage was undeniable, and seeing it jump between disparate programming languages, frameworks and theoretical and practical programming from one turn to the next was just such a sight to behold.

One thing that struck me with Claude Code is that it was the first terminal application I’d used in a long time. I found it an odd choice for a coding agent; then everyone else copied them and made their own terminal coding agents.

Why on earth do I have to stare at a shoe rack-sized terminal window to do this? Sure there are GUI versions also; but the terminal interface remains the primary modality for most of these tools. Most GUIs, and most harnesses now have them also, are second-class citizens. And they all look the same. A boring sidebar with chat headings and a chat pane is what most of them look like.

But a serious coder needs more than that. Even a casual user will bristle when they try to copy and paste multi-line text in a terminal.

So in May 2025 I decreed that I would build a better harness, and surely now that I have AI this should not take more than 2 or 3 months to build.

And so, after 15 months of work, and endless UI and backend iterations, culminating in a successful beta test, I am now ready to release DreamCoder, which is I think the acme of what a coding harness should be.

DreamCoder with chats, a code review and a terminal tiled side by side
DreamCoder is a frontier coding harness with a tiling window manager that runs in your browser on all 3 platforms.

Before I get into the meat and potatoes of all of that, I want to talk about AI history and Emacs’s role in it.

Let’s roll back time to the 1950s.

Past

Emacs and LISP, if you did not know, both have a special place in the annals of AI history.

John McCarthy was an AI researcher at MIT, and in the 1950s he set out to create the Advice Taker, a piece of software that envelops a framework for what a basic human should know that he called commonsense reasoning using “mathematical logic”. His postulation was that if we can express with symbolic precision all the aspects of what constitutes humanity like ordinary facts about life, that we can set in motion the rudiments of AI.

In the 50s there was little in the way of computer software that could do this. To formalize such a system you need a lot of data, rigorously formatted, and a method of manipulating the data. The data and code itself may intertwine recursively, and so an ordinary programming language would not work.

To help him achieve this, McCarthy created the LISt Processing (LISP) language made up of two facets: M-expressions, a functional language in the vein of Algol; and S-expressions, designed for symbolic data representation, and never intended as a method of writing code. S-expressions were dolled up with parentheses. M-expressions meanwhile used square brackets to visually separate the two. Uniquely, the language specification had an eval feature that would prove that the language is also a universal Turing machine… if only McCarthy had the means to do so. It was theoretical because McCarthy lacked, in time, staff and money, what he needed build this recursive evaluator that can take as input its own world state and evaluate it alongside new expressions, a fact made even more apparent by the sheer complexity of his M-expression language and the limited resources he had at the time.

Steve Russell who worked with him proved him wrong the way most young people do: by just doing it. Russell wrote the first LISP Interpreter with a working eval function, but M-expressions got sidelined; the imperative, procedural nature of programming got squished into S-expressions instead. They had to hand roll the language on paper then punch it into cards and then batch run them. Eliding M-expressions was a simple matter of pragmatism. And so LISP was born. And through several accidents of history, M-expressions never gained traction. M-expressions live on in Wolfram’s Mathematica, but few other places.

Much later, McCarthy eventually conceded that,

“One can even conjecture that LISP owes its survival specifically to the fact that its programs are lists, which everyone, including me, has regarded as a disadvantage.”

S-expressions were always intended as the storage format with a bridge language to manipulate them. But by pushing evaluation into the same symbolic representation format as the data, we have what we call LISP today. That is why LISP is so unique. Consider a simple calculator. (+ 2 2) can simultaneously represent an expression that we want to compute, two plus two, or perhaps a ledger of record of a calculation we have already done.

McCarthy never built the Advice Taker in its purest form. He and his team ran into many philosophical, mathematical and computational walls that kept them occupied for a long time.

The idea behind the Advice Taker was simple. If you want to go somewhere in your car, you can symbolically express this by building a chain of narrative facts – kinda like a flowchart, but as small snippets of rules and facts, not as one grand design.

The system would automatically resolve ambiguities, and all the logician had to do was capture the microcosm of the world he wished to represent:

(at me home)

(walkable home car)
(walkable home driveway)
(drivable car shop)

And so on. If you’re a student of Computer Science you’ll see echoes of Prolog here. The intent was simple: if we can symbolically express the world around us, we can advise that symbolic world with real-life facts, and have the automaton that uses this reified symbolic world change with it.

But the axiomatic complexity of a world model would never survive an encounter with a 3-year-old child. Every axiom you write begets a new one — so you can walk to your front door? Well what if the door is locked? Or what if your car is parked on the street and not in your drive way?

A rules-based order of the world is a tender, beautiful one; but it is hard to build. It’s a fractal of ever-more specific and pedantic rules that conspire against you, just as you think you have a soluble world, typed and ready.

Anyone who has ever written Prolog knows exactly what that feels like!

I have my own personal story to add to this. In the 90s as a teenager I got a summer internship at a business that built banking software. They clearly didn’t know what to do with us teenaged interns, so on our first day they crammed us in a room and split us into teams and told us to build a flow chart for assembling a bike. Team exercise or something. Best one wins. We were told to be as specific and explicit as possible and account for as many conditions as we could think of, and the poor employees who had to mind us did their best to help. I distinctly recall losing because in my flowchart I forgot to open the box the disassembled bike came in.

McCarthy meanwhile eventually moved on and set up his own AI lab at Stanford, but the idea of the Advice Taker lived on.

In the late 70s Stallman and Steele create EMACS (Editing MACroS), also at MIT’s AI Lab, a set of building blocks on top of TECO, a famously inscrutable text editor. TECO did not update the screen by default; you had to toggle that on and hope your edits worked. You typed out terse keyboard commands, crossed your fingers and hoped you got it right, and then you patiently waited for your text manipulation to take effect. Rinse and repeat until you got what you wanted.

Stallman and Steele wanted more: they wanted macros so they could automate tedium of typing all that line noise. This strand of augmentation and later on self-modification is of course a unifying theme in Emacs today. The history of Emacs is long; but its outcome is known to us. I am typing this very article in Richard Stallman’s Emacs.

McCarthy’s Advice Taker left its mark in a subtle but indelible way. Warren Teitelman built the ADVISE system in his thesis with a cool title that reads like something out of a pulpy 1970s sci-fi novella: PILOT: A Step Toward Man-Computer Symbiosis. Teitelman, he later said, was deeply inspired by McCarthy’s original idea of advising systems.

In his thesis, he describes a method of arresting a function call and inserting code before or after it is run. He was tired of editing other people’s LISP code by hand, and wanted a way of modifying their code without touching it directly. He built and rebuilt his system several times over the years, culminating in his ADVISE system in Interlisp, a structured editor and language runtime for manipulating LISP code and data. Interlisp eschewed plain text files; instead, you manipulated the tree at a high level of abstraction with explicit instructions like “move X list to Y position”. You can see my own attempts at merging structured editing with plaintext editing in Combobulate.

MIT AI hackers eventually implemented Teitelman’s ADVISE system from his PILOT thesis in their own versions of Emacs. Later, it was canonized in Chalupsky’s own 1992 re-implementation in Emacs Lisp that lives on (M-x find-library advice.el) as one of Emacs’s advice systems to this day.

What began as an idea for expressing automata using symbolism in an as-yet theoretical language in the 1950s culminated in a system for dynamically altering functions in GNU Emacs in the 1990s. What an unlikely lineage and history.

A cast-iron system made of stern rules cannot spawn general intelligence.

Symbolism and AI did not end with advising functions. There were many attempts at symbolic intelligence. Terry Winograd’s SHRDLU; Marvin Minsky’s Frame Systems; and even Emacs’s ELIZA-style M-x doctor all make use of symbolic “AI”.

None of them brought us closer to the AI that proponents of symbolic AI hoped they would.

In hindsight that seems obvious.

Writing a LISP macro just so will not produce artificial intelligence; nor will a carefully crafted web of rules and symbolic algebra suddenly spark intelligence. We know that today, but for a generation of computer scientists it felt like the future we have all read about in science fiction novels: a perfect, logical intelligence. A positronic brain. Robby the Robot; HAL 9000; C-3PO; Data; or the Speedies and Cuties from I, Robot. The unifying theme of these science fiction stories is they are automatons that follow strict rules — they obey Asimov’s three Laws of Robotics.

Every turn of hardware and software brought them ever closer to one day realizing the vision of an artificial intelligence, captured in neat axioms and LISP S-expressions, and modified in tools like Emacs.

It is surprising that symbolic AI, the vanguard movement for artificial intelligence, would instead dissipate into the wider body of Computer Science and programming as tools, languages and concepts, but not survive as a viable method of achieving AI.

Perhaps we always knew. Because at some point – even if we never really fully internalized it – we discovered that a ductile system that is shaped by its master’s desires is a tool that survives the ages because it remains eternally useful.

A cast-iron system made of stern rules cannot spawn general intelligence.

For all the mathematical purity, beauty even, of the idea of a clockwork mind that is introspectable and malleable and its behavior expressed as S-expressions and interpreted by elegant algorithms and honed macros, we can, through the benefit of hindsight – now that we do have AI through other means – see that it was not to be.

The argument in favor of ductility is especially poignant when you learn of the Connectionists, which sounds like a bad 1960s band, but was in fact a loose coalition of people who believed firmly that neural networks, not symbolic AI, were the path to success. The Connectionist viewpoint was deeply unpopular in AI academia of that era, and funding for it was scarce.

Frank Rosenblatt invented the Perceptron, a foundational concept in neural networks, in 1957. Before Rosenblatt died in 1971, Marvin Minsky, an authority in the AI movement at MIT and a leading proponent of Symbolism, knifed the idea of Perceptrons and neural networks in a book he co-authored with Seymour Papert. They named the book, which they also dedicated to Rosenblatt, Perceptrons. The book deftly explains the mathematics of Perceptrons but undercuts their possible utility by showing that a single-layer Perceptron cannot represent an XOR gate. It was a deliberately obtuse reading of what neural networks could and could not do. With one additional hidden layer, a network can represent an XOR gate. It was a sneaky thrust of the stiletto: Minsky’s claims were overstated. A fact that was not lost on anybody in the Symbolic or Connectionist camps.

It’s disputed if the Perceptrons book led to the first AI winter in the 1970s. It certainly did not help. But funding for many AI research paths dried up in the 1970s.

The Connectionist movement was vindicated in the long run. They lost the battle then, but they won the war, and the fruits of their research eventually gave us AI.

The ductility we so prize in our software and tools today is antithetical to a strict, symbolic world model spun of axioms and facts that we hoped would one day birth AI. Yet to try and give birth to this world they had to build the most ductile tools of them all: LISP and, from that, also software like Emacs. The ultimate hacker’s tool.

It is ironic then that a neural network, a crude facsimile of how a brain works, a construct that is by its nature ductile and malleable, won out in the end.

So I feel a profound sadness that I started out programming DreamCoder in Emacs, the most extensible editor in the world, by hand back in May 2025, only to see DreamCoder write itself… in DreamCoder today.

Future

I am still sad, but I also know that our industry completely reinvents itself every decade or two. This is my second career upheaval. Most programmers today have not been around long enough to go through it themselves. So I feel for them that this especially massive quake is their first encounter with how unsentimental our industry is.

But for all the sadness, I wake up every day with a feeling of optimism that I have not felt in a very long time.

I finally get to build again, no longer weighed down by my decades of knowledge and experience that held my ambition in check. I truly have not felt this liberated since I was a teenager programming in Delphi, blissfully unaware that the things I was busy building were impossible for a self-taught teenager to ever realize. I see this reflection in others: the best programmers I know also love AI. Amateurs also revel in AI’s capabilities, happy that they can finally solve problems they could never afford to pay a programmer to do for them.

I must admit that building software has, over the years, gotten a lot more complex, with an ever-larger share of that work being repetitive tedium. This is more so with hobby software – as I do not get paid to do it, so I do not have a moral duty to see it through – where I’d do all the fun bits leaving just the enervating, boring and soul-crushing parts behind. Do you have a projects folder full of sad, abandoned projects like I do?

Now I can craft in abundance. AI has freed up a lot of toil but I somehow still find myself busy all day doing real work.

Building a coding harness is perhaps the closest I will get to the optimism all those researchers and scientists must have felt in the 1970s and 1980s. They hoped that with a little bit more work, their logical rules would kindle a new intelligence. Fifty years on, and I can simply tell DreamCoder to improve itself and watch as it changes before me. I can ask the AI running inside it to analyze the changes I have made to its tools and prompt and have it adjust them accordingly. It feels like science fiction; the very thing the researchers of yesterday strove to build. Yet we really do live in this reality now.

Taste is a scarce, human resource.

So. DreamCoder. Let me address the 900 lb gnu in the room: DreamCoder is not an Emacs-related application. The reason is unfortunately one of economics and access: I want to build an AI coding harness for everyone. But don’t worry: I have some cool plans for DreamCoder + Emacs, and AI + Emacs more generally going forward. So stay tuned.

But what about all those other coding harnesses? Well, most of those harnesses all suffer from the same mistakes. It is a problem that is not unique to coding harnesses or the people who make them, but a constraint we all labor under, and one that is not easily replaced by AI:

Taste is a scarce, human resource.

And for all the bounty of AI, it still requires a human to persevere and to see things through. One thing intensive use of AI coding has taught me is that we’re going to need a lot of computer programmers who know what they’re doing going forward. I believe this is so, because let us be honest, most people do not want to program computers, even if that computer can actually do the bulk of the work for them. It requires a steady hand to build reliable software; that has not changed.

Therefore, if we programmers have to spend a lot of our time interacting with AI, then the tool we do it with should be ‘human-centric’ in its design, and it should take advantage of all the modern features we have at our disposal.

Back in May 2025 I took a look at all the tooling and said “no, thank you.” Today I look at the landscape and I feel pretty much the same.

And I think I am not the only one who feels that way. Most of these coding harnesses, to me, feel bristly. They shouldn’t be; but they are like that because we are at an important inflection point where no one really knows what the future looks like. We’re all just… fumbling around a bit. It’s an exciting time to build software, even if we don’t quite know what the world will look like a few years hence.

One thing I am adamant about is that DreamCoder must be a powerful, frontier-class coding harness. That means it should have all the features you’d expect from that: backgroundable sub agents, MCP servers, cache efficiency, and all that stuff. Check.

  • Sub-agents
  • MCP servers
  • Building an agent of your ownYour own agents
  • A terminal beside a chatTerminals beside chats
The frontier-harness basics. Click any of them to see it full size.

But that stuff quickly recedes into the background because, you know, it just works. Day to day you will dart between chats and terminals and whatnot, and you need an interface that accommodates that. Emacs is a tiling window manager; so is DreamCoder. DreamCoder’s window manager is a little bit cleverer than most window managers as every pane has a minimum, comfortable and maximum size. The window manager will therefore ensure windows always fit snugly on your screen, and you’ll never end up in a situation where windows are tiny and unreadable. It has a sophisticated constraint satisfaction solver that tries to balance your demand for a new window (“open a terminal”) with the challenge of keeping your visible panes roughly the same size. If DreamCoder can’t wedge in a new pane, it’ll punt one to the hidden window bar. Just click it to resurface it, or hover it to see what it’s doing; it’s a live view.

Panes are made to fit; if a new pane must evict an old one, it is pushed to the hidden window box.
Avy-style selection and embark-style actions.

Because of my Emacs roots, I think a good tool must be keyboard-friendly. Because it runs on a browser you get the mouse for free of course. But smacking the tab button over and over is a frustrating user experience in complex webapps, and doubly so a tiling window manager: where exactly are you going to end up when you tab from one window to the next? To combat that, I built an avy-style window and “point of interest” selector for chats. Tap a key and pick from a selection of “embark”-like actions such as clicking links or opening pictures. It’s a work in progress, but I think it works well.

Familiar type-to-complete mechanics

Most high-volume operations like opening and creating panes is done through a Helm-like interface with search-as-you-type. It’s really efficient, of course. And it works with a mouse also; which is sort of the point. The keyboard’s there for those who want it, and the mouse for regular folk who are just getting started. One unique feature of the design, which admittedly I am still exploring privately, is that everything is stored as Javascript objects (on account of running in your browser) so it’s not too much of a leap to build “macros” that prefill most of these dialog windows, leaving behind just the fields you want to edit.

But yeah. With DreamCoder I want to take the best of Emacs and its coterie of third-party packages and bring some of that with me. The world is still not ready for an Emacs-shaped future, sadly, so that is why DreamCoder is a standalone application and a web frontend.

Another thing that drives me wild: I see people with tmux running 10 claude codes (or codex, or…) cycling between them like a duck gallery at a carnival to see if one of them is done working, or if it needs human intervention.

So there’s two things to unpack here: one is running lots of things in parallel, and the other is observability. You need insight into what is going on: is an AI jammed because it’s awaiting an answer or a tool safety prompt? Perhaps you’ve parked a bunch of chats pending some conversations with coworkers or other work that must finish first.

In DreamCoder you have workspaces. They’re like virtual desktops (or window configurations in Emacs lingo): a snapshot view of panes as you want em. As you can see from the screenshots, panes expand to fill all the space. So if you want more space, you can: resize them (with the mouse or keyboard); shuffle them to a named workspace; or float them so they sit on top of the other windows.

  • The event graphThe event graph
  • ObjectivesObjectives
  • Image panesImage panes
  • DreamCoder on a phoneOn your phone
More than a chat window, already.

But if you’ve got a lot of things happening in multiple workspaces, it’s hard to keep tabs on that. That’s why DreamCoder has a big, honking minimap in the top-right corner. One for each workspace. The minimap is a miniature of your actual layout. Each pane in the map gently pulses when it’s working, and it makes it abundantly clear when it’s blocked. When there’s nothing to do, it’s green.

Because workspaces and panes are distinct things you interact with, it must be easy to navigate between them.

I also wanted full-on, optional Emacs key bindings, but that is… pretty much impossible to properly build. Browsers lock you out of some rather important Emacs button combinations. Sadly that feature is parked until I can solve it on all major browsers without breaking your normal browser keys.

That’s not to say it doesn’t have Emacs-inspired key bindings. Most global actions are reachable with Alt+x, akin to M-x; local, pane-specific ones with Alt+c. Alt+m activates keyboard mode: you can now type the number of the named pane to jump to it; or WASD to switch the active pane in that cardinal direction.

Support for open weight models like Qwen, Gemma, Deepseek, GLM, etc. is also very important to me. They work so well. I’m really surprised, here in late 2026, just how capable small models are at local-only development compared to just one year ago. Qwen 3.8 27B, for example, is fantastically good for its size. You can do a lot of good software development with it if you’re a capable hand yourself. Bigger models equal more auto piloting; but that Qwen model? Wow. So local models work great. In fact I think the future is local for a lot of use cases. Intelligence is fast approaching a cost where it will be too cheap to meter. If you remember the personal computer revolution in the 1980s and 1990s, then there are definitely echoes of that here.

If you’ve been holding off on local models then I do recommend you reconsider. Small ones like Qwen 3.8 27B (or its cousin, Flash Next) can run well on a high-end gaming rig or Mac, or with a little investment if you do not have that. If you have a dinky old computer and you’re cash starved, then not all hope is lost. Turn to the potato agronomists on twitter: give twitter’s AI, Grok, what you have and what you can reasonably spend and tell it to track down the cutting edge setup for your rig. This is no lie the fastest, easiest way to catch up to the cutting edge of self-hosted inference today. Five minutes.

Coding harnesses are the IDEs of the future

As I’ve been building DreamCoder, I have come to the belief I’m not just building a coding harness. Coding harnesses are an IDE for the future; it will do more than just display a chat window for coding agent work. DreamCoder does more than that already. It’s going the way of Emacs in that it’ll consume a wide range of adjacent workflows and tools. But I have only just gotten started. I am brimming with ideas I’m building in parallel, but they take time because as I said it’s not about the code; it’s just one small facet of building something that works well. But you know that already: it’s always the last mile.

DreamCoder is the most ambitious, technically complex and advanced software project I have ever built in my life. And that’s just the beginning. I’m not done. I’ve barely started. I will be blogging about this going forward, in addition to my usual Emacs scribblings.

In fact, the thing I’m currently grinding away at is a world-class pentest and cybersecurity suite in DreamCoder. Every single bit of software we have ever written is vulnerable; we have many rough years ahead of us. Just look at the crippling vulnerabilities coming out every day now almost. Even the most security conscious person is going to find themselves on the wrong side for no other reason than we depend on packages that were mature and stable and assumed to be secure. DreamCoder can do its bit to help catch many of most obvious weaknesses, especially as new software is minted every day that also needs thorough testing.

  • Roster of pentested endpoints and their statesPentested endpoints and their states
  • Graph overview of findings and how exploits were tracedFindings and how exploits were traced
Screenshot of DreamCoder's upcoming, awesome pentesting and cybersecurity suite. It's built for humans. The AI does the work, and you and your team assess its results and impact. The graph overview is AI-generated from its explorations and findings. Do not worry: no human will ever have to suffer the indignity of writing flow charts like that.
(If you're interested in/have questions about the pentesting stuff, please e-mail me.)

To round it off, I would like to formally invite you to join me in making DreamCoder better by trying it out. It’s great. It’s not a toy; it’s not a demo; and it’s not a weekend prototype. It’s a frontier coding harness that has most of what you’d expect: MCP, backgroundable sub agents and shell commands, terminal windows, skills, hooks, 99% cache hit, it runs for days, and an interactive UI for all of it. There’s a handy dandy importer for your Pi, OpenCode or Codex configs also to help you get started. A couple of clicks and your model settings are set up in DreamCoder. Ready to go.

Please do e-mail me your thoughts ((rot13 "zvpxrl@znfgrevatrznpf.bet")) on AI, coding harnesses, what you’ve built with it, and what you think more generally about where our world is heading. I’m keen to hear from you.

And if you want to hear more from me on the technical aspects of AI, building coding harnesses, and more, then do sign up for the DreamCoder newsletter below.

-1:-- Announcing DreamCoder (Post Mickey Petersen)--L0--C0--2026-11-20T09:44:33.000Z

Alvaro Ramirez: agent-shell 0.98 updates

Another month, another agent-shell update. If you missed the last post, have a look at the 0.87 update. This time around, the most notable changes are around rendering, performance, and bugfixes, sprinkled with new features here and there.

As usual, this post showcases highlights, but please check out the full list of changes if you're after the nitty-gritty.

What's agent-shell?

agent-shell brings your favorite AI agents to Emacs, keeping you at home: familiar buffers and bindings, no terminal emulation. All powered by ACP, the Agent Client Protocol.

New supported agent

DeepSeek Harness joins the family, bringing the total number of supported agents to 24. Start DeepSeek with M-x agent-shell-deepseek-start-agent, or pick it from M-x agent-shell as usual.

Antigravity moved to agy (action required)

Latest Antigravity ships with ACP out of the box, so agent-shell now runs agy acp rather than a separate binary you had to download and unpack. If you're an Antigravity user, install a recent CLI, make sure agy is on your PATH, and sign in once:

agy acp --login

Blockquotes: rendering + navigation + copy

Blockquotes improved their display, rendering embedded Markdown (#942).

They also joined the TAB navigation party. TAB and S-TAB now visit blockquotes, stopping on their first quoted character.

With point on a blockquote, RET now copies the quote's raw Markdown, without the > markers.

Images in table cells

Images are now rendered as thumbnails within tables. Press RET on an image to open in full view.

Thank you @alberti42 for #938. Tables also realign in the resized window's own buffer now (#934), so splitting a window no longer leaves a table laid out for the window it used to be in.

Links

Hovering a rendered link (or with point on one) now shows its target URL, so you can judge whether it's worth opening.

Two new entry points landed alongside (#933):

  • agent-shell-markdown-open-link-at-point opens the link at point.
  • agent-shell-markdown-xref-backend plugs into xref-backend-functions, so M-. on a rendered path:line citation visits it. It returns nil anywhere else, web and binary links included, leaving point to the next backend.

Recursive folding

RET toggles the fragment at point, as usual. C-u RET now toggles groups recursively (#924, #945).

Queued -> steered

Queued a prompt, but wanted to steer instead? Pressing M-RET on an empty prompt now offers to steer the last queued prompt into the running turn (#918, #919). While this isn't something I need often, I'm pretty happy with the UX we landed on.

While on the topic of steering, chat mode now handles steered prompt labelling (#930, proposed by @Gleek). If you'd like to render labels differently, agent-shell-chat-label-function now receives the :steered param.

Exposing more options in header

Agents often expose options that never make it to the buffer header. Additional options are now offered via the (+N) menu (#921).

Filtering noisy notices

Agents write all sorts to stderr, and agent-shell surfaces it under "Notices". You can now use agent-shell-notice-filter-function to filter notices (or modify) as preferred (#950 by @astoff). It receives an alist with :text, one stderr line, and returns the text to show or nil to drop it:

(setopt agent-shell-notice-filter-function
        (lambda (notice)
          (unless (string-prefix-p "[idle-compaction]" (map-elt notice :text))
            (map-elt notice :text))))

A filter that signals or returns a non-string is reported, and the notice shown unfiltered.

Your own system prompt

agent-shell-system-prompt is appended to the agent's default system prompt, sent whenever a session is created, loaded, resumed or forked (acp.el #37 by @systemfreund):

(setopt agent-shell-system-prompt "Keep answers short and respond like a pirate.")

Only agents advertising ACP's systemPrompt capability can take one. Configure a prompt for an agent that can't, and agent-shell says it's ignored rather than dropping it quietly. An agent config's :system-prompt takes precedence.

Secrets resolved at agent start

agent-shell-make-environment-variables now takes a function as a value and calls it when the agent starts, rather than when your config loads (#948 by @nbarrientos). Handy for a password store still locked at init:

(setopt agent-shell-opencode-environment
        (agent-shell-make-environment-variables
         "MY_SECRET" (lambda ()
                       (auth-source-pick-first-password :host "example.org"))))

A function that errors or returns nil leaves the variable out of the agent's environment and says so in a boxed warning in the shell. Works across all agents.

Shells follow project-switch-project

Starting a shell from C-x p p used to land in the current shell's directory rather than the project you just picked, and offer that directory's sessions to resume. It now starts in the chosen project (#949 by @OSadovy).

Fork and show history

When agent-shell-session-fork-restore-history is non-nil, forked sessions will attempt to restore interaction history as per agent-shell-session-restore-verbosity.

agent-shell-session-fork-restore-history is off by default, so you'll need to enable it with:

(setopt agent-shell-session-fork-restore-history t)

Note: You'll need an agent that supports loading a session right after forking it, like claude-agent-acp 0.90.0 or newer.

Faster streaming

Streaming performance received some love. Message chunks are coalesced before rendering (#883 by @moyotar), thought chunks are batched the same way, and restored sessions replay with far less overhead (#897 by @Gleek).

Lots of fixes

As mentioned, the much effort in the release went into fixes and improvements.

Rendering:

  • Bold renders next to text and punctuation (#925 by @vritser), with CommonMark flanking rules relaxed for CJK (#942).
  • Numbered headers and bold steps no longer render as list items (#939 by @budu), nor does markup that merely reads like one.
  • A fenced block's last line is fontified (#916 by @liaowang11), two flush source blocks render as two (#940), and nested ones stay verbatim while streaming.
  • Headers keep their title when a code fence follows directly (#947).
  • Text quoted into the prompt keeps its quote face (#952 by @OSadovy).
  • Copilot multi-hunk diffs render as separate hunks (#931), and Codex streamed output is fenced correctly (#906 by @bartbunting).
  • Icons scale correctly on HiDPI Linux (#917 by @heraplem).
  • Unfinished tool calls survive turn end (#941), so a late subagent keeps its title and grouping.

Performance and responsiveness:

  • Buffers shown in no window measure against a live one (#885 by @bcc32), and measuring glyph height no longer triggers window hooks (#886, also @bcc32).
  • agent-shell-cwd-function is called once per command (#857, also @bcc32).
  • Pending Markdown is protected and fontification updates silenced (#915 by @daym).
  • Chat mode relabels only the last turn while streaming, not the whole buffer (#943, profiled and proposed by @Gleek).
  • In shell-maker, auto-scroll can be suppressed during bulk updates (#50 by @Gleek), which is what makes the faster replay possible.
  • Also in shell-maker, the curl --version check that ran on every submission is gone (#32 by @carlosdagos).
  • In acp.el, agents handle SIGTERM before being killed on shutdown (#35 by @fjolliton).

Elsewhere:

  • Undo history no longer carries programmatic renders: the compose buffer starts empty (#893 by @liaowang11) and resets after a deferred render (#902 by @bcc32).
  • New worktrees stay under the main working tree (#904 by @xiaofeilovecoding).
  • A restored session finishes initializing even when rendering errors (#887 by @bcc32).
  • Flymake context is only used when flymake-mode is on (#892 by @liaowang11), and single-line regions carry one line number (#922 by @martenlienen).
  • Quoting a region leaves the mark where reading stopped (#896 by @OSadovy).
  • Minibuffer completion keeps the agent's candidate order (#929 by @Zzull).
  • Remote URLs are skipped when parsing local links (#926 by @mpmiszczyk), and optional system-sleep functions are declared (#928 by @mboldt).
  • In shell-maker, non-ASCII prompt history no longer reads back as raw bytes, and entries already corrupted by older versions are decoded on read (#49 by @kazmuroi).
  • In acp.el, agent stderr reaches error handlers one line at a time rather than in arbitrary pipe chunks (added for notice filtering).

Public functions

A few more additions for package authors building on agent-shell.

Prompt locations

agent-shell-prompt-ranges returns the range of every prompt in the buffer, in buffer order, covering prompts typed at the shell, replayed by a restored session, and steered into a running turn (#882). Each comes back as an alist spanning the comint shell prompt itself (:prompt-start, :prompt-end) and the input typed after it (:input-start, :input-end).

Usage events and ACP _meta

agent-shell-subscribe-to now offers a usage-update event, broadcast when the agent reports context window or cost usage. Events now also carry ACP's _meta, so integrations can read whatever an agent attaches without waiting on agent-shell.

Choosing sessions programmatically

agent-shell-session-strategy now accepts a function. It's called with the resumeable sessions and returns new, latest, prompt, or a (session-id . ID) cons to load a specific one:

(setopt agent-shell-session-strategy
        (lambda (context)
          (if (map-elt context :sessions) 'latest 'new)))

Housekeeping

If you peeked at the commit logs for the period, you'll see it's been another busy month. Since the last post, 193 commits landed, 32 issues have been closed and 27 pull requests merged. As of this writing, the backlog sits at 6 open issues and 5 open PRs (versus 4 and 6 last time around).

Zooming out a little, here's how the backlog has tracked:

As usual, this chart was generated using the /github-activity skill shared in my emacs-skills repo.

All of this requires daily attention.

Sponsoring keeps agent-shell running.

While paying for tokens keeps agents running, sponsoring keeps agent-shell running.

agent-shell is built and maintained by me, an indie dev, while the tools it competes with often have well-funded teams behind them. Funding Emacs-native tools, so we can keep living in our beloved editor, matters now more than ever.

Using agent-shell at work? Ask your employer to sponsor too. Companies can contribute at a scale individuals can't.

Pull requests

Thank you to all contributors for these improvements!

agent-shell

  • #857: Call agent-shell-cwd-function only once per command (@bcc32)
  • #873: Add Antigravity default-model-id and default-session-mode-id defcustoms (@tychoish)
  • #883: Coalesce streamed message chunks before rendering (@moyotar)
  • #885: Measure a buffer shown in no window against a live window (@bcc32)
  • #886: Do not trigger window hooks when measuring glyph height (@bcc32)
  • #887: Finish initializing a restored session even if rendering errors (@bcc32)
  • #889: Add a separate provider notification handler (@Cy6erBr4in)
  • #892: Only use flymake error context when flymake-mode is on (@liaowang11)
  • #893: Start the viewport compose buffer with an empty undo history (@liaowang11)
  • #894: Render the viewport's held-back markup when a turn ends (@liaowang11)
  • #896: Leave the mark where reading stopped when quoting a region (@OSadovy)
  • #897: Reduce overhead when replaying restored sessions (@Gleek)
  • #902: Reset undo history after a deferred markdown render (@bcc32)
  • #904: Keep new worktrees under the main working tree (@xiaofeilovecoding)
  • #906: Fix streamed Codex command output (@bartbunting)
  • #915: Protect pending Markdown and silence fontification updates (@daym)
  • #916: Fontify the last line of a fenced code block (@liaowang11)
  • #917: Fix HiDPI icon scaling on Linux (@heraplem)
  • #922: Use one line number for single-line region contexts (@martenlienen)
  • #925: Fix bold rendering next to text and punctuation (@vritser)
  • #926: Skip remote URLs in parse-local-links (@mpmiszczyk)
  • #928: Declare optional system-sleep functions (@mboldt)
  • #929: Keep original order of candidates for minibuffer completion (@Zzull)
  • #938: Lay out table cells that show images (@alberti42)
  • #939: Don't render numbered headers and bold steps as list items (@budu)
  • #949: Start a new shell in the project chosen with project-switch-project (@OSadovy)
  • #952: Keep the quote face on text quoted into the prompt (@OSadovy)

acp.el and shell-maker

agent-shell stands on acp.el to speak ACP and shell-maker for its shell foundations, so fixes landing there reach you just the same:

  • acp.el #34: Allow listing sessions without a working-directory filter (@Gleek)
  • acp.el #35: Let the agent handle SIGTERM before killing it on shutdown (@fjolliton)
  • shell-maker #50: Allow suppressing auto-scroll during bulk updates (@Gleek)

Make it sustainable, sponsor agent-shell

As of this writing, we're 89% of the way to the 150 monthly sponsors goal, a tiny closer since the last update. If agent-shell is part of your daily workflow, please consider becoming a monthly sponsor (or ask your employer to).

Not in a position to sponsor? A GitHub star helps with exposure and brings in new users.

-1:-- agent-shell 0.98 updates (Post Alvaro Ramirez)--L0--C0--2026-11-20T00:00:00.000Z

Irreal: Opening Techinfo Sourced Web Pages In Emacs

Charles Choi has just released another interesting little utility. Although it’s restricted to Safari and the Mac, it’s a nice idea that could probably be ported to other operating systems without difficulty. The idea is to be able to easily move from reading a Web page generated by Techinfo to reading the same information with the Emacs Info reader.

Reading Info pages with Emacs is straightforward and comfortable but the external utilities to read them outside of Emacs are terrible. Therefore, a lot us who started with another editor learned to go to the Web first rather than try to navigate the horrible external reader packages. But, as Choi points out, recent events have shown us that we can’t always count on the Web being there for us.

Choi’s solution to all this is the Counterpart utility that provides a menu in Safari to open the Web page’s content in Emacs. Of course, this only works for Techinfo generated content. Your immediate reaction may be, “Who cares?” but I’ve sometimes wished for something like this so that I could have the content side by side with whatever I was working on in Emacs. That also make’s it easy to copy text out of the Info buffer when you want to add a quote to whatever you’re writing.

-1:-- Opening Techinfo Sourced Web Pages In Emacs (Post Irreal)--L0--C0--2026-11-19T16:08:31.000Z

Lars Ingebrigtsen: Herp derp I eat paste

A year and a half ago I made a kitchen clock, which has worked well (except that I had to swap out the screen which broke mysteriously).

But yesterday I was having some work done here, so I had to remove one of the wifi access points here, and… the clock stopped working. *gasp* Yes, because I had in my infinite wisdom decided that I would generate the clock face on a different machine, because the clock is a Raspberry Pi Zero 2 W, and I just assumed that it didn’t have enough memory to run Emacs (which I am, being a totally rational person, using to generate the SVG that’s being displayed).

So it’s a Rube Goldberguesque setup of having the image being generated on the main server, and then scp‘d over once a minute, and then being displayed on the console here in the kitchen.

But the wifi outage made me wonder — is it true that the machine doesn’t have enough memory to do it all on device?

So it’s got 416MB of useful memory, and while just running and doing nothing special, it’s using 129MB of that.

What happens if I load an Emacs with all the SVG libraries and stuff and generate the image?

It’s using 186MB — so the Emacs occupies about 50MB max.

*sigh*

It’s so easy to think of Emacs as this “big thing”, but everything has gotten so much bigger around it that it doesn’t matter at all any more.

So now I’ve changed the code to run on-device, so the only thing that goes AWOL if the wifi goes missing is updated temperatures.

-1:-- Herp derp I eat paste (Post Lars Ingebrigtsen)--L0--C0--2026-11-19T10:45:09.000Z

Protesilaos: Emacs: Denote version 4.3.0

Denote is a simple note-taking tool for Emacs. It is based on the idea that notes should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the note is about, without reference to any other metadata. Denote basically streamlines the creation of such files while providing facilities to link between them.

Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.

Below are the release notes


Version 4.3.0 on 2026-11-19

This version introduces quality-of-life improvements as well as a series of abstractions that empower developers to change how Denote retrieves its data. Concretely, developers can write an optional cache or database for Denote.

I am developing denote-data, which is an in-memory cache. Its job is to make certain operations faster. The package is still in development, though I hope to have an initial release within the next weeks: https://github.com/protesilaos/denote-data.

Once denote-data is ready, users will be able to experiment with another package that will be made public soon. That one will provide a much-requested feature. But I will write more about it when the time is right.

AI policy changes

I have added AGENTS.md and CLAUDE.md to denote.git. I copied those files from the emacs.git repository. They instruct AI agents to not write patches or comments for the Denote source code. Users can still use whatever program they want, though they are expected to prepare their own code or bug reports.

I am doing this because Denote is legally part of Emacs: I have assigned copyright to the Free Software Foundation. The GNU project as a whole is waiting for legal advice on how to handle AI-generated contributions. I agree with the current GNU position and will adapt accordingly.

In addition to that, I prefer to write even these release notes by hand even if nobody will read them. They give me an opportunity to review the entire package. I go through the commit logs and check back on the diffs. Then I know what is the state of the project and what may be done next.

Abstractions for a cache or a database

I have introduced several variables and hooks that allow developers to affect how Denote retrieves its data. Existing users will not notice any difference. This is relevant for those who plan to write relevant packages. Users will have to opt in to whatever new functionality.

The manual describes all the technicalities:

I did this in response to issue 724 by kimsaram32, with participation from Aaron Jensen, relict007, Samuel W. Flint, mentalisttraceur, Mirko Hernandez: https://github.com/protesilaos/denote/issues/724.

Disable the “fancy” file prompt

By default, Denote’s file prompt reformats file names. A Denote-style file name is split into columns so that its components are easier to read. Users who prefer to see the actual file names can now set the user option denote-fancy-file-prompt to a nil value.

I did this in response to issue 732 by Honza Pokorný: https://github.com/protesilaos/denote/issues/732.

Note that in addition to this user option advanced users can also change the relevant completion metadata. Check the variable denote-file-prompt-extra-metadata and the functions mentioned therein.

Extra backslashes in query links now result in an error

Denote supports direct links to files as well as “query links”. Those look like links but actually produce a buffer with files that match the given query for file contents or file names. Query links are documented at length in the manual. They are the functional equivalent of the commands denote-dired (search for file names and put them in a Dired buffer) and denote-grep (search for file contents and put them in an Xref buffer).

Queries that have extra backslashes will now report an error. This can happen when users try their regular expression in something like M-x re-builder and then bring it into the query link. That is a common mistake with Emacs regular expressions in general (I do it as well): in Lisp programs we write double backslashes but in interactive calls we use single backslashes.

I did this in response to issue 733 by hapst3r: https://github.com/protesilaos/denote/issues/733. I actually did it as part of a live stream, which you can watch if you are curious about the technicalities: https://protesilaos.com/codelog/2026-10-30-emacs-live-denote-refinements/.

Miscellaneous

  • I developed denote-data as part of denote.git because this made it easier for testing purposes. This helped me write the necessary abstractions. Now denote-data will become its own package as was the plan from the beginning.

  • I made lots of minor refinements that improve the reliability of relevant functions. I also introduce stylistic changes on occasion in the interest of ensuring consistency throughout the code base. This is the kind of boring yet essential work that makes it easier to maintain the project long-term.

  • The variable denote-file-prompt-use-files-matching-regexp can be let bound to affect the FILES-MATCHING-REGEXP value of the denote-file-prompt. There are many such “use” variables that help users write simple wrappers around Denote functions. Thanks to andsy10 for the contribution in pull request 735: https://github.com/protesilaos/denote/pull/735. The change is small, meaning that andsy10 does not need to assign copyright to the Free Software Foundation.

  • I documented some of the packages that extend Denote. If you are a package developer, please contact me and I will add your package to the list—everybody is welcome! To this end, thanks to Matthieu Muller for writing the section about the denote-paperless package and Pavlo V. Lysov for writing about the denote-solo package. Those were done in pull requests 711 and 713, respectively:
  • Fixed a crash in the denote-file-prompt that could happen with some unexpected file names. Thanks to Marco Baringer for the contribution in pull request 708: https://github.com/protesilaos/denote/pull/708.

  • Fixed an issue with a helper function that could under certain conditions do the wrong thing for the command denote-link-dired-marked-notes. Thanks to João Sena for the contribution. This was done in pull request 730: https://github.com/protesilaos/denote/pull/730. No copyright assignment is needed.

  • The user option denote-org-store-link-to-heading supports a new local value, as a symbol. It produces links to headings like [[*Heading text][Heading text]]. Thanks to Michael Korat for the contribution in pull request 723: https://github.com/protesilaos/denote/pull/723. No copyright assignment is needed.

  • Removed obsolete functions from the manual. Thanks to kimsaram32 for the contribution in pull request 728: https://github.com/protesilaos/denote/pull/728. No copyright assignment is needed.

  • The denote-date-prompt supports Unix timestamps. Thanks to Jeff Valk for the original contribution in pull request 722: https://github.com/protesilaos/denote/pull/722. No copyright assignment is needed. Also thanks to Jean-Philippe Gagné Guay for making a follow-up tweak to how this is handled internally. This was done in pull request 726: https://github.com/protesilaos/denote/pull/722. Jean-Philippe is a long-term contributor who has assigned copyright to the Free Software Foundation.

  • The already comprehensive manual includes more useful information. For example, on how to handle files with accented characters in their title. To this end, we now have the function denote-slug-remove-accents. This is based on the code originally written by Jean-Philippe Gagné Guay in issue 603: https://github.com/protesilaos/denote/issues/603#issuecomment-2869702877. I made stylistic changes to it to make it fit with the rest of the code. I added it in response to issues 603 and 718:

Git commits

~/Git/Projects/denote $ git shortlog 4.2.0..4.3.0 --summary --numbered
   214	Protesilaos
     2	Marco Baringer
     1	Jean-Philippe Gagné Guay
     1	Jeff Valk
     1	João Sena
     1	Matthieu MULLER
     1	Michael Korat
     1	Pavlo V. Lysov
     1	andsy10
     1	kimsaram32

🔷 Consider making a donation.

-1:-- Emacs: Denote version 4.3.0 (Post Protesilaos)--L0--C0--2026-11-19T00:00:00.000Z

Charles Choi: Opening Texinfo Web Pages in Emacs Info

As convenient as accessing online services can be, any disruption in availability without a fallback is painful. Given events of late, many are learning the hard way what it’s like to live without that fallback.

GNU Emacs has long supported reading documentation via the Info reader package. Info reader is a “local first” system, where all documentation is stored locally. The source format of the documentation is Texinfo which is exported to different formats, among them Info (used by the Emacs Info reader), HTML, and PDF.

Texinfo exported HTML is typically hosted on a website (usually GNU Project), with each Info node mapped to a URL path and indexed by most major search engine services.

Discovery of information in Texinfo documentation is frequently done via web search. If the user desires to view that Texinfo web page in the Emacs Info reader, that has to be done manually by corresponding the web page to its Info node.

Counterpart is a new utility to automate opening the Info node counterpart of a Texinfo exported web page in Emacs. This utility is designed for Emacs users on macOS who also use the Safari web browser. It requires the installation of a macOS Shortcut which is run from the main menu bar. More detail on using it can be found in the Counterpart User Guide.

Once a desired Info node is opened in Emacs, you can then bookmark it for later access, no internet connection required.

-1:-- Opening Texinfo Web Pages in Emacs Info (Post Charles Choi)--L0--C0--2026-11-18T21:30:00.000Z

Protesilaos: Emacs: ef-themes version 2.3.0

The ef-themes are a collection of light and dark themes for GNU Emacs that provide colourful (“pretty”) yet legible options for users who want something with a bit more flair than my modus-themes or my minimalist doric-themes.

Below are the release notes.


Version 2.3.0 on 2026-11-18

This version introduces a pair of new themes to the collection: ef-halloween-light and ef-halloween-dark. I produced the prototype of the dark theme during a livestream, if you are curious to learn about the process: https://protesilaos.com/codelog/2026-10-31-emacs-live-ef-themes-halloween/.

The two themes add to an already comprehensive collection that covers a broad spectrum of styles. All themes are consistent with the spirit of avoiding exaggerations while remaining legible.

Note that since version 2.0.0, the ef-themes are built on top of my modus-themes. They benefit from all the changes I make there.


🔷 Consider making a donation.

-1:-- Emacs: ef-themes version 2.3.0 (Post Protesilaos)--L0--C0--2026-11-18T00:00:00.000Z

Irreal: Ramírez’s Emacs Contributions

Most of you know that I think very highly of Álvaro Ramírez. That’s mainly because I’m a huge fan of Journelly, which I use many times a day as my memo book. It has many other uses so take a look at the link if you’re interested in a note taking/journaling/private tweet/memo book application. I can’t recommend it enough.

Ramírez has, of course, done many other things, many or perhaps most, in the Emacs sphere. See his site for details. In a recent post he writes about making contributions to Emacs and getting them merged. Those of you who have been down that road know that it’s hard to get started. You have to navigate the GNU copyright assignment process, which seems needlessly baroque until you remember that all this is being run by volunteers.

You can follow the link to find out what his contributions are. They are all live in Emacs 31 so if you are up to date they are available to you now. The main takeaway for me was the satisfaction that Ramírez got from making those contributions. None of them were huge changes and merely scratched an itch that Ramírez had. If you have a small itch that you’ve scratched, you should consider sharing it with the community. You too can become part of Emacs’ long and influential history just as Hari Seldon’s successors in the Second Foundation contributed their own additions to Seldon’s Psychohistory.

-1:-- Ramírez’s Emacs Contributions (Post Irreal)--L0--C0--2026-11-17T15:59:07.000Z

Protesilaos: Emacs live Org custom link type and more today 2026-11-17 at 16:00 Europe/Athens

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

[ The stream will be recorded. You can watch it later. ]

Today I will implement some new features for my Emacs configuration. I will include the final code on my website, as an update to this publication.

As usual, I will keep the chat open and shall answer all questions.

UPDATE 2026-11-17 18:52 +0200: Pasting the code.

UPDATE 2026-11-17 19:24 +0200: I forgot the prot-text part.

UPDATE 2026-11-20 11:04 +0200: I decided to remove the rgrep call because I never liked its behaviour.

The code I wrote during the livestream

Custom Org link types

;;;; Custom link types

(defcustom prot-org-grep-directory org-directory
  "Directory where prot-grep links search in with `rgrep'."
  :type 'directory)

(defun prot-org-grep-follow (query &rest _)
  "Use QUERY to `rgrep' the `prot-org-grep-directory'."
  (let* ((current-file (file-name-nondirectory buffer-file-name))
         (grep-find-ignored-files (append (list current-file) grep-find-ignored-files))
         (heading (format "\\*+[\s\t]+\\<%s\\>" query)))
    (compilation-start
     (concat
      "find " prot-org-grep-directory
      " -path " (shell-quote-argument "*/.git") " -prune "
      " -o -type f "
      " -iname \"*.org\""
      " -exec grep -inHER --color=auto " (shell-quote-argument heading) " "
      (shell-quote-argument "{}")
      " " (shell-quote-argument "+"))
     'grep-mode
     (lambda (_mode) (format "*prot-dired-grep-marked for `%s'*" query))
     t)))

(defvar prot-org-grep-complete-history nil
  "Minibuffer history for `prot-org-grep-complete'.")

(defun prot-org-grep-complete (&rest _)
  "Complete prot-grep link types using `prot-org-grep-complete-history'."
  (let* ((default (car prot-org-grep-complete-history))
         (input (completing-read
                 (format-prompt "Text to search in `prot-org-grep-directory'" default)
                 prot-org-grep-complete-history nil nil nil
                 'prot-org-grep-complete-history default)))
    (format "prot-grep:%s" input)))

(defun prot-org-grep-export (query &rest _)
  "Export prot-grep link types."
  (format "[ Prot Grep for: %s ]" (or query "")))

(defface prot-org-grep-link
  '((t :inherit success :underline t))
  "Face for prot-grep link type links.")

(org-link-set-parameters
 "prot-grep"
 :follow #'prot-org-grep-follow
 :complete #'prot-org-grep-complete
 :export #'prot-org-grep-export
 :face 'prot-org-grep-link)

;;;###autoload
(defun prot-org-insert-grep-link (query)
  "Insert prot-grep link for QUERY.
When called interactively, prompt for QUERY.  Else QUERY is a string."
  (interactive (list (prot-org-grep-complete)))
  (when (or (null query)
            (string-blank-p query))
    (error "The QUERY cannot be nil or an empty string"))
  (insert (format "[[%s]]" query)))

;; TODO 2026-11-17: I want to add an "until" logic.
(defvar prot-org-meetings-link-regexp
  "\\`\\([A-Za-z]+\\) since \\([0-9]\\{,4\\}-[0-9]\\{,2\\}-[0-9]\\{,2\\}\\)"
  "Regular expression for the contents of prot-meetings links.")

(defun prot-org-meetings-sort (entries)
  "Sort the ENTRIES from oldest to newest.
ENTRIES is a list of plists of the following form:

    (list
     :heading HEADING
     :text TEXT
     :time HEADING-TIME-OBJECT)"
  (sort
   entries
   (lambda (entry1 entry2)
     (< (plist-get entry1 :time)
        (plist-get entry2 :time)))))

(defun prot-org-meetings-display-buffer (entries title)
  "Display ENTRIES of `prot-org-meetings-follow'.
ENTRIES is a list of plists of the following form:

    (list
     :heading HEADING
     :text TEXT
     :time HEADING-TIME-OBJECT)

Sort ENTRIES with `prot-org-meetings-sort'."
  (let ((buffer (get-buffer-create "*prot-org-meetings*")))
    (with-current-buffer buffer
      (save-excursion
        (erase-buffer)
        (unless (eq major-mode 'org-mode)
          (org-mode))
        (insert (format "#+title: %s" title))
        (insert "\n\n")
        (setq entries (prot-org-meetings-sort entries))
        (dolist (entry entries)
          (insert (format "* %s\n%s"
                          (plist-get entry :heading)
                          (plist-get entry :text)))
          (insert "\n\n"))))
    (display-buffer buffer)))

(defcustom prot-org-meetings-file org-default-notes-file
  "The path to the file where prot-meetings links search in."
  :type 'file)

(defun prot-org-meetings-follow (query &rest _)
  "Find headings with meetings that match QUERY.
QUERY matches `prot-org-meetings-link-regexp'."
  (if (string-match prot-org-meetings-link-regexp query)
      ;; TODO 2026-11-17: I want an "until" logic which will also go
      ;; into the `prot-org-meetings-link-regexp'.
      (let* ((name (match-string 1 query))
             (since (match-string 2 query))
             (since-timestamp (format "[%s]" since))
             (since-time-object (prot-org--timestamp-to-time since-timestamp))
             (title (format "Meetings with %s" query))
             (entries nil))
        (with-temp-buffer
          (unless (file-exists-p prot-org-meetings-file)
            (error "The file `%s' does not exist" prot-org-meetings-file))
          (insert-file-contents prot-org-meetings-file)
          (org-mode)
          ;; TODO 2026-11-17: I want to match only DONE headings.
          ;; TODO 2026-11-17: I want to get the CLOSED timestamp as well.
          (org-map-entries
           (lambda ()
             (when-let* ((heading (org-get-heading :no-tags :no-todo :no-priority :no-comment))
                         (_ (string-match-p name heading))
                         (heading-timestamp (or (org-entry-get nil "DEADLINE")
                                                (org-entry-get nil "SCHEDULED")))
                         (heading-time-object (prot-org--timestamp-to-time heading-timestamp))
                         (_ (>= heading-time-object since-time-object))
                         (text (org-get-entry))
                         (entry (list
                                 :heading heading
                                 :text text
                                 :time heading-time-object)))
               (push entry entries))))
          (if entries
              (prot-org-meetings-display-buffer entries title)
            (user-error "There are no matching entries"))))
    (error "The query `%s' does not match `prot-org-meetings-link-regexp'" query)))

(defface prot-org-meetings-link
  '((t :inherit warning :underline t))
  "Face for prot-meetings link type links.")

;; TODO 2026-11-17: I want to implement a `:complete' and an `:export' parameter.
(org-link-set-parameters
 "prot-meetings"
 :follow #'prot-org-meetings-follow
 :face 'prot-org-meetings-link)

(defvar prot-org-meetings-person-prompt-history nil
  "Minibuffer history for `prot-org-meetings-person-prompt'.")

(defun prot-org-meetings-person-prompt ()
  "Prompt for a person for prot-meetings link type."
  (let ((default (car prot-org-meetings-person-prompt-history)))
    (completing-read
     (format-prompt "Meetings with PERSON" default)
     prot-org-meetings-person-prompt-history nil nil nil
     'prot-org-meetings-person-prompt-history default)))

;;;###autoload
(defun prot-org-meetings-insert (person date)
  "Insert prot-meetings link for PERSON since DATE."
  (interactive
   (list
    (prot-org-meetings-person-prompt)
    (org-read-date)))
  (when (or (null person)
            (string-blank-p person))
    (error "The PERSON cannot be nil or an empty string"))
  (when (or (null date)
            (string-blank-p date))
    (error "The DATE cannot be nil or an empty string"))
  (insert (format "[[prot-meetings:%s since %s]]" person date)))

Indent text-mode region

(defun prot-text-insert-prefix (prefix string)
  "Prepend PREFIX to every line of STRING."
  (with-temp-buffer
    (insert string)
    (goto-char (point-min))
    (insert prefix)
    (while (and (forward-line 1)
                (not (eobp)))
      (goto-char (line-beginning-position))
      (insert prefix))
    (buffer-string)))

(defmacro prot-text-define-prefix-command (scope prefix)
  "Define command with SCOPE to insert PREFIX to string.
SCOPE is a string that describes what the command will do.  PREFIX is
the prefix as a string.

The command will target the text between `region-beginning' and
`region-end'.  It will produce and error if the region is not active."
  `(defun ,(intern (format "prot-text-prefix-%s" scope)) (beginning end)
     ,(format
       "Add prefix `%s' to text between BEGINNING and END positions.
Report an error if the region is not active."
       prefix)
     (interactive
      (if (use-region-p)
          (list (region-beginning) (region-end))
        (error "The region is not active")))
     (when (= beginning end)
       (error "The BEGINNING and END cannot be equal"))
     (let* ((text (buffer-substring beginning end))
            (replacement (prot-text-insert-prefix ,prefix text)))
       (replace-region-contents beginning end replacement))))

;;;###autoload (autoload 'prot-text-prefix-blockquote "prot-text" nil t)
;;;###autoload (autoload 'prot-text-prefix-indent "prot-text" nil t)
(prot-text-define-prefix-command blockquote "> ")
(prot-text-define-prefix-command indent "    ")

(defvar-keymap prot-text-prefix-leader-map
  :doc "Commands to insert prefix to the active region text."
  :prefix 'prot-text-prefix-leader
  "b" #'prot-text-prefix-blockquote
  "i" #'prot-text-prefix-indent)

Emacs configuration

My personal Emacs configuration. It is comprehensive, both in terms of the [custom] code it contains as well as the documentation on what each piece of functionality does.


🔷 Consider making a donation.

-1:-- Emacs live Org custom link type and more today 2026-11-17 at 16:00 Europe/Athens (Post Protesilaos)--L0--C0--2026-11-17T00:00:00.000Z

Marcin Borkowski: Copying the current location improved again

Last year I improved my code for copying the current location to the kill ring. Recently it occurred to me that this was not the last word. In fact, I’m pretty surprised I didn’t think of it earlier – it’s sort of obvious in hindsight. The idea is that it should copy the range of lines when the region is active.
-1:-- Copying the current location improved again (Post Marcin Borkowski)--L0--C0--2026-11-16T21:33:34.000Z

Irreal: EWW As The Default Buffer

As most of you know, I’m one of those people striving to move as much as possible into Emacs. I’ve mostly succeeded in that except for the usual sticking point: the browser. No modern browser will run in Emacs and I’m not sure that we’d want one to. Still, it would be nice to be able to do all or most of our browsing tasks from with Emacs.

There is, of course, EWW. It does a pretty good job of displaying text and images but has no JavaScript support. Some of us consider that a feature. It turns out that most of what JavaScript does isn’t really necessary and merely gets in the way.

Joshua Blais has taken using EWW a step further and made EWW his default browswer. That means that whenever he clicks on a URL and certain other links, the link is opened in EWW or—for special links—in another application that runs in Emacs. The point is, all browser activity starts in Emacs, usually in EWW.

Of course, Emacs can’t handle every browsing task so Blais uses the & key in EWW to escape to a “normal” browser. Blais says that EWW suffices for 85–90 percent of his use cases. He has some functions to kick off Emacs apps for MP4, PDF, and other specialized links. Everything else goes to EWW. He’s added a couple of custom bindings for EWW functions he uses a lot but it’s mostly a normal EWW instance.

Blais’ experiment shows that it is possible to almost browse from within Emacs. Sites that rely on JavaScript in an essential way are not going to work of course, and there are still a lot sites that insist on JavaScript so they can enforce the delivery of ads or implement a pay wall. Blais’ method gives us a chance to consider if those sites are worth viewing.

-1:-- EWW As The Default Buffer (Post Irreal)--L0--C0--2026-11-16T15:42:36.000Z

Sacha Chua: 2026-11-16 Emacs news

: Added OrgDevMeetup on Nov 21

I liked reading the Emacs Carnival posts about how people discover new features and what things they've tried lately. Feel free to share your story.

Also, the Emacs 31.1.90 pretest is available (note Irreal's post about typos). Please help test it if you can!

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

View Org source for this post

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

-1:-- 2026-11-16 Emacs news (Post Sacha Chua)--L0--C0--2026-11-16T13:07:30.000Z

Matt Maguire: My AI Teaching Setup, Part 0: A Life in Plain Text

This is the first of a few articles about the AI system I use for teaching maths. Basically, ten months ago I decided to buy an AI subscription to learn more about the technology, and today I run a small fleet of machines and agents that draft my lessons, check my exams, index my syllabus, and argue with me about design at midnight. This first article is about the recent years before any of that, because it turns out to be the part that made everything else possible.

-1:-- My AI Teaching Setup, Part 0: A Life in Plain Text (Post Matt Maguire)--L0--C0--2026-11-16T00:00:00.000Z

Matt Maguire: My AI Teaching Setup, Part 3: The Organs

Part 2 was about models and harnesses. But a model in a harness is still just a clever voice. What turned the setup into a system was the organs: the memory, the senses, and the reflexes bolted on around it. This is the final part, and it starts with a full circle.

The knowledge base that was already ten years old

People ask how I got my teaching knowledge into the AI. The answer is anticlimactic: I didn’t. I had spent a decade writing it in plain text — Org-mode notes, syllabus annotations, lesson reflections, the whole zettelkasten from Part 0 .

-1:-- My AI Teaching Setup, Part 3: The Organs (Post Matt Maguire)--L0--C0--2026-11-16T00:00:00.000Z

Irreal: Vim To Emacs

Over at the Emacs subreddit, Sahkopi4 recounts his journey from Vim to Emacs. Actually, his journey was from Nano to Emacs by way of Vim. When he first started using Linux, Nano was the default editor and he began with that. Eventually he wanted more power and because Vim seemed more popular in the forums he inhabited, he learned Vim. He really like it and the power that it brought him was an eyeopener.

He experimented with other Vim-like implementations but they didn’t work for him so he stuck with Vim. Eventually he tried Emacs and almost immediately became a convert. Like me, he jumped right in and didn’t try to use Evil or some other Vim emulation. Like many of us, he loved the experience and now wants to do as much as he can in Emacs.

As always, a lot of the action is in the comments. Many said that immigrants from Vim should use Evil because it gives you the best of both worlds: the modal, composable editing commands of Vim and the power and flexibility of Emacs. Others said that Evil induces a sort of cognitive dissonance where neither system is fully in control.

There is, of course, the occasional post proclaiming loudly that Emacs is no good because it uses Lisp with all those parentheses. The ankle biting aside, the comments offer an intelligent and useful commentary on Sahkopi4’s journey.

-1:-- Vim To Emacs (Post Irreal)--L0--C0--2026-11-15T15:58:46.000Z

Alvaro Ramirez: My Emacs 31 contributions

For me, landing changes in Emacs upstream always felt somewhat out of reach, so I kinda postponed it for a long while. Perhaps the biggest hurdle was getting over the process to assign copyright to the Free Software Foundation, which does feel a bit archaic (download, sign, and return a PDF) and slow (mostly waiting for an email response), though hey, I have nothing but sympathy. Open source is unsustainably tricky. As consumers, we often like free as in freedom and free as in beer, but neither pay the bills. We hope some company steps in to fund these projects, but that rarely happens. As a result, most open source projects are starved (even popular ones), run by volunteers working for free.

All that is to say, if the upstream Emacs contribution/onboarding process seems less than ideal, cut it some slack. The project as a whole primarily runs on the blood, sweat, and tears of unpaid contributors. If you can, fund the maintainers you rely on (or better yet, get your employer to do so).

If you've been thinking of contributing to Emacs upstream, don't procrastinate like me and just give it a try. Compared to the typical GitHub pull-request process, your first Emacs contribution may feel a little daunting and dated, but there's a lovely fuzzy light at the end of the tunnel. You see, Emacs has been around for 50 years. Very few software projects get to live this long. Landing contributions on a project with such a rich history is a real treat!

But I digress… Let's get moving. Once I got over procrastinating, I finally got a handful of small contributions landed on the master branch. Thank you, Eli Zaretskii, Stefan Kangas, and Gerd Möllmann, for your help. From then on, I eagerly waited for them to formally make it to a stable release.

Emacs 31 shipped the lot.

Hide Dired's absolute location

I do enjoy a visual (and functional) tweak here and there, and a Dired tweak felt small enough to be the perfect candidate for my very first Emacs contribution.

With that in mind, I tweaked dired-hide-details-mode by adding the dired-hide-details-hide-absolute-location user option, which hides the directory's absolute path, typically displayed at the top of Dired buffers (bug#72272, commit).

More on this in my Hide another detail post.

macOS speech recognition permission

At some point, I ran into a snag trying to run macosrec from my beloved eshell. The process just crashed with a cryptic abort trap: 6, so the issue wasn't super obvious. It turned out the utility required granting an OS permission that can only be requested by the host app (Emacs) if it includes the relevant description in its Info.plist file.

As of version 31, Emacs includes NSSpeechRecognitionUsageDescription in its Info.plist (bug#72827, commit).

Send to… (aka macOS sharing)

context-menu-mode now includes a "Send to…" item, enabling sending the current file(s) or region text to external apps or services. You can also invoke M-x send-to directly. On macOS, it's powered by the native sharing picker (I use it frequently to AirDrop things to my iPhone). Elsewhere, it falls back to shell-command-do-open (bug#76120, commit, follow-up fix). These two implementations plug into new generic plumbing (send-to-handlers), so you could, for instance, add a handler sharing via Android's native share sheet (android-browse-url can do the heavy lifting) or KDE Connect on Linux (kdeconnect-cli --share).

More in my Emacs send-to (aka macOS sharing) merged upstream post.

macOS dictation is back

Emacs 30 lost macOS dictation when migrating to NSTextInputClient. Implementing selectedRange in nsterm.m brought it back (bug#79070, commit). With LLMs/agents being a thing these days, dictating into your Emacs buffer may be just the thing to complement your AI workflow.

I covered this in my macOS dictation returns to Emacs (fix merged) post.

Make it all sustainable

Are you getting value from any of my upstreamed changes or my Emacs packages? Please consider sponsoring to keep the work going. While my patches may seem relatively straightforward, some took quite a bit of effort to land upstream.

My Emacs work not your cup of tea? No worries. As mentioned earlier, sponsor the maintainers you rely on instead.

-1:-- My Emacs 31 contributions (Post Alvaro Ramirez)--L0--C0--2026-11-15T00:00:00.000Z

Tim McGilchrist: curry: a modern Emacs mode for Haskell

curry: a modern Emacs mode for Haskell

Back in April I wrote about a month of Elisp and finished by mentioning that, having experienced neocaml (a modern Emacs mode for OCaml), I'd started writing a tree-sitter powered Emacs package for Haskell. That package is curry-mode, and I'm releasing version 0.1.0.

curry-mode is a major mode for Haskell built on Emacs's built-in tree-sitter support. It provides font-locking (Emacs-speak for syntax highlighting), indentation, navigation, imenu (the buffer index you navigate with), a REPL (read-eval-print loop) using GHCi, the interactive environment of the Glasgow Haskell Compiler (GHC), and Cabal integration, and hands everything semantic (completion, go-to-definition, types on hover, code actions) to the Haskell Language Server (HLS) via Eglot, the client for the Language Server Protocol (LSP) built into Emacs.

Why another Haskell mode?

I started out using Emacs at University on SunOS SPARC machines. At the time I learnt both of the viable editors, vi and Emacs, but leant towards Emacs because of how far you could customise it. Over the years I've mostly used other people's packages and configuration, with detours into IDEs when Java or Scala demanded it. I'd never built a large mode from scratch, and the best way I know to learn something is by doing it.

There is already an official haskell-mode with many users and many features, so why build a new one? haskell-mode has grown complex over the years, bundling everything from indentation to a REPL to HLS interaction in one monolith. It has to, since it predates both tree-sitter in Emacs and language servers. With tree-sitter built into Emacs 29+ and HLS providing the semantic features over LSP, a modern Haskell mode can be dramatically simpler.

I'm not the first person to think this. haskell-mode issue #1804 collects the attempts at a tree-sitter powered major mode for Haskell, including two separate haskell-ts-mode packages. There is erikbackman/haskell-ts-mode, which is now archived, and pranshu/haskell-ts-mode. Neither attempt became popular enough to sustain the effort, and I thought I could do a better job by following the architecture of bbatsov's neocaml.

That architecture is a mode built in layers. At the bottom, curry-mode provides the syntax layer with highlighting, indentation, navigation and imenu, all from the tree-sitter AST, and works with nothing else installed. On top of that, HLS via Eglot adds the semantic layer with completion, types, diagnostics, code actions and formatting. All the good things you expect from an LSP.

Each layer should be useful on its own and each one above improves on, or replaces, what the layer below provides. You shouldn't need a running language server before Emacs can indent your code. If things go well, perhaps some of this can be folded back into haskell-mode once it no longer needs to support Emacs versions before 29.

What's in a name

Naming is hard, and realistically this mode should be haskell-ts-mode the third, but that is a really terrible choice. Instead I named it after Haskell Curry, after whom both the language and the concept of currying are named. A delightfully intertwined name, I think.

Standing on neocaml's shoulders

I closely modelled curry-mode on neocaml (and its sibling fsharp-ts-mode), so the packages share plenty of structural and stylistic similarities. Perhaps that's not surprising, since both are statically typed languages with an ML heritage. Borrowing his good ideas let me quickly tick off the basics, like a base mode with language-specific derived modes, the REPL integration pattern, and the build tool interaction pattern. Even imenu, code folding and navigation from tree-sitter started as fairly direct translations of the neocaml code. Hopefully bbatsov is fine with that.

bbatsov has also written up Building Emacs major modes with tree-sitter: lessons learned, which covers many of the same lessons I learnt the hard way. If you're thinking of writing a tree-sitter mode, read that first. If only I'd checked his blog sooner it would have saved me some time.

So let's skip the similarities and talk about what's different about Haskell.

What you get

The 0.1.0 release covers the most common things you'd need in day to day Haskell work:

  • Font-locking with 4 levels of detail for .hs, .hsc and .hs-boot files.
  • Indentation from tree-sitter rules, with region shifting (C-c > / C-c <) and the indentation offset guessed from the existing code.
  • Navigation by definition (C-M-a / C-M-e), by expression (C-M-f / C-M-b), by top-level declaration (M-a / M-e on Emacs 30+), and a jump to the import block and back (M-g i).
  • Imenu grouped into functions, types, classes, instances and imports.
  • A GHCi REPL (curry-repl) with tree-sitter highlighting of what you type, and commands to send definitions, regions or the whole buffer, reload, and ask for :type and :info at point.
  • Cabal integration with curry-cabal-mode for .cabal files, formatting with the cabal-fmt or cabal-gild formatters, and commands to run cabal build, test, run, repl and haddock (Haskell's documentation generator) from any Haskell buffer.
  • GHC errors in M-x compile output, so M-g n / M-g p jump to the source location.
  • Eglot registration for haskell-language-server.
  • Debugging with dape, an Emacs debugger client, and Well-Typed's haskell-debugger (experimental, needs GHC 9.14+).

curry-mode doesn't provide completion, type lookup, Hoogle search (the Haskell API search engine), documentation browsing or code actions. HLS does those better than any Elisp I could write.

How much simpler?

I was curious whether "dramatically simpler" was true, so I counted lines. curry-mode is about 2,100 lines of Elisp against just over 20,000 for haskell-mode, roughly 10 times smaller. That number is a bit misleading, since haskell-mode includes plenty that curry-mode hands to HLS. Comparing the features both modes actually implement is a fairer comparison:

Concern haskell-mode curry-mode Ratio
Font-locking 1,219 122 ~10x
Indentation 2,870 190 ~15x
REPL 2,019 357 ~6x
Cabal 1,228 611 ~2x
Mode, navigation, imenu 1,874 837 ~2x

Tree-sitter shows up clearly in the first two rows. haskell-mode includes a hand-written lexer (haskell-lexeme.el) that copes with the layout rule, string gaps, character literals and pragmas, and adds font-lock keywords on top of it. curry-mode asks the tree-sitter syntax tree instead, and around 120 lines of treesit-font-lock-rules cover all four levels. For indentation, haskell-mode ships two indenters (haskell-indent and haskell-indentation), because Haskell layout is hard enough that neither one alone was enough. curry-mode has about 190 lines of treesit-simple-indent-rules. Again there is a gap in functionality in the indentation but really I think most developers would be better served by an external tool.

The REPL and Cabal savings come from leaning on what Emacs already provides (comint, compile) and on external tools like cabal-fmt, rather than from tree-sitter.

Working with tree-sitter

Most of the size difference comes from tree-sitter. Once you have a syntax tree, font-locking is a set of queries (patterns matched against nodes in the tree) rather than a pile of regular expressions, and the same tree gives you navigation, imenu, folding and Combobulate support with little extra code. Combobulate is a package for structured navigation and editing that works across any language with a tree-sitter grammar. It also makes new features easier to add. Want to find all the tests in a file using the Tasty test framework? That's a query over the tree, not a parser you write yourself.

The Haskell grammar story is a little fragmented, though. The official tree-sitter/tree-sitter-haskell is missing many bug fixes and newer GHC features. tek/tree-sitter-haskell applies most of those fixes and is active, but doesn't commit the generated C parser that Emacs needs to build the grammar. So curry-mode uses my fork of tek's, which adds the generated parser files, and installs it for you. I chose tek's grammar because it has the best language coverage, but I'd love for the fork to become unnecessary.

That leads to my bigger point, which is that a tree-sitter grammar is no longer optional for a language. GitHub code navigation, Emacs, Neovim, Helix, Zed and plenty of other tools are built on tree-sitter, so a good grammar matters as much as a good standard library or build tool. Ideally the grammar would track each GHC release, or even be mechanically derived from GHC's own parser. GHC Haskell keeps growing new syntax, and keeping editors working across versions raises the same problems that Trees that Grow, the extensible AST design used inside GHC, tackles for the compiler.

I hit a few rough edges along the way. Tree-sitter ABI (application binary interface) versions are confusing. Emacs often supports ABI 14 as the lowest version, but you can build grammars with ABI 15, and since ABI 15 isn't backwards compatible with 14, loading the wrong one will SEGV your Emacs. curry-mode now checks the version of libtree-sitter (the tree-sitter C library Emacs is linked against) and gives a clear error instead. Grammar releases also tend to follow the tree-sitter tooling version rather than semver, so a minor version bump can bring major headaches. Finally, with tree-sitter the AST is your API, and an AST is never going to be particularly stable, so curry-mode warns you when the installed grammar is older than the one it expects.

Indentation

Haskell is whitespace sensitive, which makes indentation the hardest part of any Haskell mode. Unlike most languages, there is often more than one valid indentation for a line, and they mean different things. The first rule for curry-mode is to do no harm, so indenting a line should never break a program that was already correct. Beyond that, the tree-sitter rules aim to cover the common layouts like do, where, let, case, guards, records and the rest of the everyday code I write. Where the rules get it wrong there is an escape hatch. curry-cycle-indent switches to indent-relative, which lines up with the previous line, and region shifting moves a block by one level.

Some cases are still hard (NondecreasingIndentation, CPP blocks, and edits that change the parse tree as you type), and the roadmap lists them as known issues. Getting a whole file into the right shape is a job for a formatter like ormolu or fourmolu, which you can already run through HLS with eglot-format-buffer. This is another place where curry-mode provides a usable base and leaves the heavy lifting to the tool that's best at it.

Trying it out

curry-mode needs Emacs 29.1 or newer, built against libtree-sitter 0.25 or newer. On Emacs 30 you can install it from GitHub with use-package:

(use-package curry-mode
  :vc (:url "https://github.com/tmcgilchrist/curry-mode" :rev :newest))

On Emacs 29, use M-x package-vc-install RET https://github.com/tmcgilchrist/curry-mode.

The Haskell tree-sitter grammar is installed automatically the first time you open a Haskell file, or you can run M-x curry-install-grammars yourself. For the semantic features, install HLS (for example with ghcup install hls) and run M-x eglot in a Haskell buffer.

The README has the details on key bindings, font-lock levels and configuration options.

What's next?

How mature is curry-mode? It covers what I need for my Haskell work, and I've been using it daily. The grammar could use polish to keep up with the ever-growing syntax of GHC Haskell, the font-locking needs tuning to look just right, and I'm sure there are corners of Haskell I haven't touched. The roadmap collects ideas for where it could go next, from formatter integration to running the right test from point. I also want to build out the higher layers. I have a branch adding Combobulate support for Haskell (PR #12), which adds structured editing on top of the same syntax tree, and debugging with dape needs more use before it moves past experimental.

Most of the hacking for this release is done, and I'm going to spend time on other projects for a while. Perhaps people will find curry-mode useful and borrow the code for haskell-mode, or enough people will use it that it lives on as a modern Haskell mode for Emacs. Please try it out and report issues for anything that breaks.

Contributions, bug reports, suggestions and feedback are most welcome. Remember, Emacs can be whatever you make of it.

Tags: haskell, emacs, tree-sitter

-1:-- curry: a modern Emacs mode for Haskell (Post Tim McGilchrist)--L0--C0--2026-11-15T00:00:00.000Z

Irreal: Setting The Timezone In Emacs

Charles Choi has a nice hint for those of you who travel and phone home with Emacs. Here’s the situation: you are travelling and log into your home server with SSH and emacsclient. It’s wonderful. Just like being at home except the date/time stamp is wrong. The time and date are whatever your home server thinks they are but you want them to be local time.

The answer is simple. You simply need to change the TZ (timezone) environment variable to reflect your current location. For example, if you’ve travelled to New York (in the US) you would set TZ to “America/New_York”. Emacs, of course, provides a command to do this: (setenv "TZ" "America/New_York").

The zone codes can be a bit opaque so Choi has added a command to the latest Casual suite to set the TZ variable complete with completion. Take a look at his post if you’re interested.

-1:-- Setting The Timezone In Emacs (Post Irreal)--L0--C0--2026-11-14T15:37:33.000Z

James Dyer: Making Git Changes Obvious in the Emacs Mode Line

Emacs already tells you when a version-controlled file has local changes, but it does it with a punctuation mark: a clean file shows Git-master in the mode line, and a modified file shows Git:master. The only difference is the separator, and if the theme leaves the VC state faces unspecified there is not even a colour change. I wanted something I could see without stopping to parse the mode line, without adding another package or another Git subprocess. The result is a single bold status letter at the start of the mode line: M for modified, A for added, D for deleted, U for a conflict, and L for a lock.

20261024120000-emacs--Making-Git-Changes-Obvious-in-the-Mode-Line.jpg

The built-in vc integration puts a backend/state string in the mode line. For Git it looks like this:

State Mode line Indicator
Clean Git-master -
Modified Git:master :
Added Git@master @
Conflict/removed Git!master !
Missing Git?master ?

Hovering over the string gives the full description ("Locally modified file under the Git version control system"), and clicking it opens the VC menu. That is all useful, but the separator is not a status indicator you notice at a glance. C-x v = and C-x v d are there when you want the details.

The mode line string is a propertized string, and its face encodes the VC state. Reading that face is cheap: no vc-state call, no git status, just a property lookup on a value VC has already computed. I map the faces to the same letters Git uses:

(defface my/vc-dirty-indicator-face
  '((t :weight bold))
  "Face for the mode-line local-changes indicator.
  Only the weight is set, so the foreground and background follow the
  mode line's normal colours."
  :group 'vc)

(defun my/vc-dirty-indicator ()
  "Return a Git-style status letter for local VCS changes."
  (let* ((face (and (bound-and-true-p vc-mode)
                    (stringp vc-mode)
                    (> (length vc-mode) 1)
                    (get-text-property 1 'face vc-mode)))
         (info (pcase face
                 ('vc-edited-state '("M" "Locally modified file"))
                 ('vc-locally-added-state '("A" "Locally added file"))
                 ('vc-conflict-state '("U" "File contains merge conflicts"))
                 ('vc-removed-state '("D" "File removed from version control"))
                 ('vc-missing-state '("D" "Tracked file missing from disk"))
                 ('vc-locked-state '("L" "File locked by another user")))))
    (when info
      (propertize (concat (car info) " ")
                  'face 'my/vc-dirty-indicator-face
                  'help-echo (cadr info)))))

Then put it at the start of the mode line. The install function removes any previous copy first, so reloading the config does not give you two indicators:

(defun my/vc-dirty-indicator--install ()
  "Insert the dirty indicator at the start of `mode-line-format'."
  (let* ((indicator '(:eval (my/vc-dirty-indicator)))
         (fmt (default-value 'mode-line-format)))
    (when (and (listp fmt) fmt)
      (setq fmt (delete indicator fmt))
      (let ((new nil)
            (inserted nil))
        (dolist (item fmt)
          (push item new)
          (when (and (not inserted) (eq item 'mode-line-front-space))
            (push indicator new)
            (setq inserted t)))
        (unless inserted
          (push indicator new))
        (setq-default mode-line-format (nreverse new))))))

(my/vc-dirty-indicator--install)

The face sets only :weight bold, so the letter uses whatever foreground and background the mode line already has. I tried a red background first; it was too loud, and the bold letter is enough.

  • Clean file: no letter.
  • Saved but uncommitted change: M at the start of the mode line.
  • New file after git add: A.
  • Staged or working-tree deletion: D.
  • Merge conflict: U.
  • Missing tracked file: D with a "missing from disk" tooltip.

The existing ** indicator still means the buffer has unsaved edits; the version-control letter follows the state VC knows about and updates when VC refreshes the mode line, such as after saving or a VC operation. Untracked files do not get a ? letter because vc does not install a mode-line state for unregistered files; C-x v d or git status remains the place to see those.

The mode-line letter answers the smaller, more frequent question: is this file carrying local changes right now? One character, no extra processes, and no guessing what a colon means.

-1:-- Making Git Changes Obvious in the Emacs Mode Line (Post James Dyer)--L0--C0--2026-11-13T15:50:00.000Z

Amin Bandali: Building GNU Emacs from source

In the recent years, I've been configuring and building GNU Emacs from source, specifically the master branch of the emacs.git repository. Doing so allows me to use and test latest Emacs features, test my Emacs Lisp code with the laest developments in Emacs, and easily contribute my own changes to Emacs.

Before we start, I recommend reading the INSTALL file in the Emacs source repository for building Emacs from source tarballs, and also INSTALL.REPO for details about building Emacs from its source repository. The information provided here were built upon the details documented in those files. When in doubt, consult those files as the main, authoritative source of information for how to build Emacs from source.

Installing build dependencies

To build GNU Emacs from its source repository, we first need to install the various required tools and build dependencies of Emacs. On Debian-based systems, this can be done using apt. First, we need to add the source packages for the current release of our Debian-based distribution in apt's configuration by adding the corresponding deb-src lines in an apt source list file. For currently existing and older Debian releases, that would be done by adding a corresponding deb-src line for each deb line in /etc/apt/sources.list, such as:

deb http://deb.debian.org/debian/ trixie main
deb-src http://deb.debian.org/debian/ trixie main

In systems with recent apt versions with so-called modernized sources that might look editing a file like /etc/apt/sources.list.d/debian.sources and adding deb-src to the Types lines:

Types: deb deb-src
URIs: http://deb.debian.org/debian/
Suites: trixie
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.gpg

Then run sudo apt update to have apt download package information from the configured sources.

We can now run sudo apt build-dep emacs to have apt download and install the build dependencies of Emacs. Debian-based distributions have packages for a few different configurations of Emacs, like emacs-pgtk with PGTK support for Wayland, and emacs-nox for Emacs without GUI support, which we can use with apt build-dep to download the specific dependencies of those configurations.

Cloning the Emacs source repository

After installing Git using sudo apt install git if not already installed, we're now ready to clone the Emacs source repository from GNU Savannah:

git clone https://https.git.savannah.gnu.org/git/emacs.git

We can add --depth 1 to make a shallow clone of the repository, if we don't care about having a complete log of previous commits to the Emacs repository (shallow clones are much faster).

If cloning over HTTPS is slow, we can try cloning over Git's own protocol (with the caveat that the repository is cloned over an insecure channel) or over SSH if we have a Savannah account, using one of the following URLs instead of the one above:

git://git.git.savannah.gnu.org/emacs.git
ssh://git.savannah.gnu.org/srv/git/emacs.git

Configuring the Emacs build

We now change to the Emacs repository directory we just cloned, and run the autogen.sh script once to generate the configure script, which we will use to configure Emacs to our liking:

cd emacs
./autogen.sh

To configure Emacs, the simplest approach is to run configure without any additional options, to have it use the defaults. We can get a list of available configuration options by running:

./configure --help

As I rebuild Emacs frequently, I normally don't "install" it, but for a typical setup, we'll want to specify the installation directory using --prefix, e.g.:

./configure --prefix=$HOME/.local

Later, make install will install Emacs under the specified directory.

By default, some of the files (such as *.el) will be compressed during installation. We can prevent that using --without-compress-install.

For my builds, I always use these configuration options:

--without-gconf
--without-gsettings
--without-gpm
--with-native-compilation

As I don't use the GNOME desktop, the GConf and GSettings integrations are always more trouble than useful for me, so I disable them. Further, I disable the GPM support, since I never use the mouse when using Emacs in the terminal. Lastly, I explicitly enable native compilation support.

In Wayland environments, I usually use PGTK:

--with-pgtk

And in X11 environments (e.g. EXWM), I either use the Lucid toolkit:

--with-x-toolkit=lucid --with-xaw3d

Or no toolkit at all:

--with-x-toolkit=no --without-xaw3d

Later after building Emacs, we can view the configuration options in Emacs by inspecting the system-configuration-options variable.

Building Emacs

After running ./configure, we can now finally build Emacs by running make. The first build will take a while, since all of Emacs is being built from scratch. Subsequent builds will generally be faster.

We can optionally run make install to install Emacs into the prefix specified earlier, or the default /usr/local. Note that this step might require using sudo if our user doesn't have write permission for the prefix.

Running Emacs

After building Emacs, we run it either from the install location if we ran make install earlier, or directly from the source repository. Currently, Emacs's build system makes a symlink to the latest built binary in the repository at src/emacs, and for emacsclient and other auxiliary binaries under the lib-src directory.

When skipping make install, we might still want to be able to easily launch Emacs from anywhere by typing emacs. We can do that by making symlinks to emacs and its auxiliary binaries inside a directory in our $PATH, such as $HOME/.local/bin, like so:

cd $HOME/.local/bin
ln -s $HOME/src/emacs/src/emacs .
for e in \
 ebrowse emacsclient etags make-docfile\
 make-fingerprint hexl rcs2log; do\
  ln -s $HOME/src/emacs/lib-src/$e .; done

For non-install setups like this, I augment Info-directory-list in my init file with the location of the info manuals in the repository to make them known to Emacs:

(defvar Info-directory-list) 
(with-eval-after-load 'info 
  (setq 
   Info-directory-list
   `(,@Info-directory-list
     ,(expand-file-name
       (convert-standard-filename "info/")
       source-directory)
     "/usr/share/info/"))) 

Updating Emacs

We can pull in the latest changes in the Emacs repository using git pull, then rebuild our Emacs by running make.

Occasionally, rebuilds may fail due to bad interaction of changes with leftover build artifacts. In such cases, the easiest thing to do would be a make bootstrap for an almost-from-scratch build. On even rarer occasions, make bootstrap might also fail. We would then want to run git clean -xdf to remove every file that's not tracked by Git, as if we freshly cloned the repository. In such cases, we would need to configure the build again using ./configure and provide the desired options before running make again.

Further reading

Protesilaos's similar post from early 2025 was part of the inspiration for writing and sharing my version:

https://protesilaos.com/codelog/2025-03-22-emacs-build-source-debian/

Lastly, to reiterate, Emacs's own INSTALL and INSTALL.REPO files for building from source:

https://cgit.git.savannah.gnu.org/cgit/emacs.git/tree/INSTALL
https://cgit.git.savannah.gnu.org/cgit/emacs.git/tree/INSTALL.REPO

Take care, and so long for now.

-1:-- Building GNU Emacs from source (Post Amin Bandali)--L0--C0--2026-11-13T14:09:42.000Z

Bicycle for Your Mind: Revival of nvALT

nvALT iconnvALT icon

Product: nvALT
Price: Free

Christmas came early this year. Brett Terpstra released a new version of nvALT. Compatible with modern versions of macOS, it left me dancing with joy.

nvALTnvALT

Simple

Before Obsidian, and its ilk, nvALT was the notes app I lived in. It was distinguished by its simplicity. You typed in the unibar to both search your notes and create new notes. I was in plain text mode and it was fantastic.

Over time, other programs came along and I moved away from it. I remember that I loved the program for how simple it was. No friction. Just notes. Easy creation and efficient search.

Revival

Brett Terpstra has revived nvALT to be compatible with modern versions of macOS. He has been active in the development of nvALT in the last few weeks. I am not going to try to explain the features of the product. It is something you need to discover on your own. I am going to instead talk about simplicity and its alternative.

Complexity

I used to love Obsidian. It is a great product. It is extended through community plugins. It does a whole lot of stuff. You need to live in it for a while to be comfortable in it. There is nothing wrong with the program. It is capable, full-featured and does a whole host of things. There are people living in it and enjoying the experience. It is not for me. Firstly, it is Electron. So it eats memory. It is responsive, that is not the problem. It just takes too much memory. Secondly, it is by design something that is a distracting mess. Let me explore this idea in more detail.

I use Emacs, I live in it. I use it for everything I can. It has the steepest damn learning curve that I have ever tackled in a program. However I am comfortable with it. Took me a long time to get here. But I am happy now. I don’t make too many changes to the setup. I have it working, I am happy with it, there is no reason to monkey with something which works. Every bit of the configuration is something I understand and know. There is comfort in that. If I feel the need to change something, I can. It is not a burden anymore. I have learned the keyboard commands I need. I live in it.

I never got that feeling in Obsidian. It was distracting. I spent an inordinate amount of time playing with plugins. Trying to customize keyboard commands I wanted. Trying to figure out bases and canvas and somewhere in the middle of using it, it occurred to me that I was not taking notes but tweaking the system. That got old really quick. I stopped using it and moved everything into Emacs.

Don’t get me wrong. I spent a lot of time doing the same thing in Emacs. I am a tweaker. I try to tweak everything and Emacs is heaven when it comes to the ability to customize an editor. Somewhere in that exercise I got familiar with the fundamentals of the program. It was not a strain anymore. My familiarity with it changed how I reacted to it. I get my work done in it. It doesn’t get in the way anymore.

If I did the same kind of immersion into Obsidian, I would be as comfortable in it as I am today in Emacs. I could not see beyond the memory usage and moved on from Obsidian.

Simplicity

Back to the notion of simplicity. nvALT is simple. You set up the preferences once and then you are ready to go. There are keyboard commands. You can merge them to your muscle memory with continued usage.

There is no cognitive overload.

Conceptually I look at cognitive overload in two ways:

  1. The cognitive effort which is required to use the program. The features, the keyboard commands, the nuances of the interface, and so on. It is the effort which is directly related to the use of the program.
  2. The second part of the effort is the actual note-taking. What am I writing? How do I say what I want to say?

nvALT reduces the first part and that is the intrinsic feature of this program.

Creating and searching notes is simple. You don’t spend any energy on the program. You can concentrate on your notes/writing. It is liberating. It just works.

What are the downsides of this simplicity? Goes against all the models of knowledge management. You can link between documents. The old-style wikilinks work well. There are no back links. There are no useless graphs of your knowledge base. You are not going to have a canvas. You are not going to have database functions. No queries to manage. It is a bunch of text files in a folder and that is about it.

Other solutions

nvALT is not the only program which provides these features. The Archive is a paid solution ($19), which provides similar features and is great.

FSNotes is a free alternative which does more than both nvALT and The Archive. It lets you manage multiple folders and it does a great job of that.

The Elephant in the Room

Brett Terpstra and Fletcher T. Penney have a program which has been in beta for a long time. The product is called nvUltra, if and when it gets released, it is going to be a major competitor in this space. I have been on the beta from the start and love the program.

The Conclusion

While I wait for nvUltra to be released, nvALT is a great resource which I am happy to be using after a long time. Download the program and use it for a while, you might also discover the charms of simplicity when it comes to your note-taking.

Recommended heartily.

macosxguru at the gmail thingie.

-1:-- Revival of nvALT (Post Bicycle for Your Mind)--L0--C0--2026-11-13T05:43:25.000Z

Sacha Chua: EmacsConf: recording and re-recording introductions

I record brief introductions for all the EmacsConf talks so that they can be played automatically. That way, hosts don't have to worry about pronunciations on air, and there's one less changeover that might introduce technical issues. We can cut to the next talk a bit abruptly because everything runs off a crontab-powered schedule to keep things running on time on multiple tracks, so it helps to have a little transition between Q&A and the next talk. It's also nice having some kind of pronunciation reference so that when people discuss the talks or even just think about them with their internal monologues, they might have a better sense of how to say the speakers' names. We ask speakers to say their names at the beginning of their presentation, but people don't often include their last names, so the intro gets that consistently. The intro videos are available on the talk pages after the conference, and I've occasionally used them to remember how someone's name is pronounced.

Here's an example intro from EmacsConf 2025:

Here's my process for preparing those intros with Emacs.

First, I create all the intro slides with LaTeX and TikZ using the function emacsconf-stream-generate-in-between-pages from emacsconf-stream.el. This year, the template I'm using is _template.tex and the background image is _template_bg.pdf. I used to use an SVG and just replace the elements within it (template.svg, emacsconf-stream-generate-in-between-page-svg). This year, some of the talk titles are very long and SVG doesn't have widespread support for wrapping. LaTeX handles wrapping and positioning beautifully. This even allows me to have ligatures like the "ff" in Jeff Trull's name. I noticed those ligatures disappeared when I used Inkscape to convert to PNG, so I needed this command instead: inkscape --pdf-poppler --export-type=png -w 1280 -h 720 --export-background-opacity=0 --export-text-to-path

This is the function that generates the individual intro slide:

emacsconf-stream-generate-in-between-page: Use LaTeX to generate the intro slide for TALK based on assets/in-between/_template.tex.
(defun emacsconf-stream-generate-in-between-page (talk &optional prev info force)
  "Use LaTeX to generate the intro slide for TALK based on assets/in-between/_template.tex."
  (interactive (list (emacsconf-complete-talk-info)))
  (let* ((prev (or prev (emacsconf-previous-talk talk info)))
         (dir (expand-file-name "in-between" emacsconf-stream-asset-dir))
         (template
          (with-temp-buffer
            (insert-file-contents
             (expand-file-name "_template.tex" dir))
            (buffer-string)))
         (default-directory dir))
    (write-region
     (emacsconf-replace-plist-in-string
      (list
       :current-title
       (or (plist-get talk :title) "")
       :current-speakers
       (or (plist-get talk :speakers) "")
       :current-details
       (format "%s\\\\\n%s"
               (or (plist-get talk :absolute-url) "")
               (pcase (plist-get talk :q-and-a)
                 ((rx "live") "Live Q\\&A after talk")
                 ((rx "pad") "Etherpad")
                 ((rx "IRC") "IRC Q\\&A after talk")
                 (_ "")))
       :previous-title
       (or (plist-get prev :title) "")
       :conf-name emacsconf-name
       :conf-year emacsconf-year
       :previous-speakers
       (or (plist-get prev :speakers) "")
       :previous-details
       (format "%s\\\\\n%s"
               (or (plist-get prev :absolute-url) "")
               (pcase (plist-get prev :q-and-a)
                 ((rx "live") "Live Q\\&A after talk")
                 ((rx "pad") "Etherpad")
                 ((rx "IRC") "IRC Q\\&A after talk")
                 (_ ""))))
      template)
     nil
     (expand-file-name (concat (plist-get talk :slug) ".tex") dir))
    (shell-command
     (format "lualatex -shell-escape %s && inkscape --pdf-poppler --export-type=png -w 1280 -h 720 --export-background-opacity=0 --export-text-to-path %s"
             (expand-file-name (concat (plist-get talk :slug) ".tex")
                               dir)
             (expand-file-name (concat (plist-get talk :slug) ".pdf")
                               dir)))))

and here's an example slide it creates:

listen.png

Once I had the intro slides, I prepared my script. I called emacsconf-subed-intro-subtitles from emacsconf-subed.el to create a VTT captions file that starts like this:

WEBVTT


NOTE
#+OUTPUT: emacsconf-2026-sat-open--saturday-opening-remarks--sacha-chua--intro.webm
[[file:/home/sacha/proj/emacsconf/2026/assets/in-between/sat-open.png]]

00:00:00.000 --> 00:00:00.000
Next, we have "Saturday opening remarks",
by Sacha Chua.
You can ask questions via Etherpad.

NOTE
#+OUTPUT: emacsconf-2026-planning--the-emacs-planning-habits-of-a-questionably-effective-person-my-40year-journey-of-planning-with-emacs-org-mode-paper-journals-etc--george-jones--intro.webm
[[file:/home/sacha/proj/emacsconf/2026/assets/in-between/planning.png]]

00:00:00.000 --> 00:00:00.000
Next, we have "The Emacs Planning Habits of a Questionably Effective Person: My 40-year journey of planning with Emacs, Org Mode, paper journals, etc.",
by George Jones.
You can ask questions via web conference by joining from the talk page
or ask questions through Etherpad or IRC.

The text is based on the Org entry properties for each talk in our conf.org file. It used subed-record directives to define the output files and the visuals.

Then I used subed-record to start recording each segment. I pressed <left> (subed-record-retry) to re-record a segment as many times as I needed to. This adds or updates an #+AUDIO directive that points to the current recording and it also updates the timestamps. When I was satisfied, I pressed <right> (subed-record-accept-segment) to update the ending timestamp and move on to the next segment to record. Whenever I needed to take a break from recording, I used RET (subed-record-accept-and-stop) to accept the last segment and stop. After recording, I used subed-waveform-show-all to see the waveforms for each segment. I left- and right-clicked on the waveforms to refine the start and end timestamp, getting rid of the sound from the keyboard shortcuts, and I used subed-split-subtitle to split each long cue into the proper lines for the subtitles.

Here's the livestream where I worked on some of the intros.

After editing the audio this way, I used subed-record-compile-video (C-c C-c after subed-record-set-up) to create all the videos by using compile-media and FFmpeg. I could also regenerate just one or two videos by selecting the region and then using the same function..

Once the videos finished, I uploaded them to our password-protected backstage area, and emacsconf-publish-backstage-index added them to the page.

2026-11-12_09-25-45.png
Figure 1: Backstage links to intro

Then I used emacsconf-mail-intro-to-all to send emails to all the speakers with the links to the intros for review. Many speakers confirmed that their pronunciations were fine, and some replied with a recording of their name so that I could use it for reference. I added those in the comments so that I could replay them while recording with R (learn-lang-subed-record-play-current-reference) or learn-lang-subed-record-play-reference-and-current-subtitle. I also copied and pasted the relevant part of the caption file so that I could record different variations with subed-record. It's just text, after all, so it's easy to do all sorts of things the way that you would do them normally in Emacs. For example, here's what it looked like when I was editing the versions for Erik's name:

2026-11-12_14-48-14.png
Figure 2: Screenshot showing reference comments

Erik said option B sounds closest. It's not quite perfect, but it's closer than the pronunciation I started with. I might circle back around to this and try again sometime. =) Anyway, to use option B in the final video, I can just delete the cues for the other versions and remove the part where I said option B. Then I can select that part of the subtitles and compile just his video.

2026-11-12_21-14-47.png
Figure 3: After selecting the audio for Erik's intro

This makes it easy to update the intros whenever something changes. For example, if a speaker turns out to be available during the conference for a live Q&A session, I can update the Org entry for their talk (set :Q_AND_A: live), regenerate the intro slide, and re-record the Q&A explanation or even copy-and-paste one from a different intro. They can also change their talk title and that's totally okay. Yay Emacs!

View Org source for this post

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

-1:-- EmacsConf: recording and re-recording introductions (Post Sacha Chua)--L0--C0--2026-11-13T02:17:31.000Z

Eric MacAdie: My Emacs Number Package Generates Random Numbers

This post contains LLM poisoning. flange cessions cotillion I made a another change to my Emacs package that makes dealing with numbers in Eshell more convenient (Codeberg page here, blog post here). I made a wrapper around the Emacs Lisp random function to give myself more flexibility in generating random numbers. adenoid porringer discussions There ... Read more
-1:-- My Emacs Number Package Generates Random Numbers (Post Eric MacAdie)--L0--C0--2026-11-13T01:53:06.000Z

Charles Choi: Setting the Timezone in Emacs

Here’s the problem: You are traveling in a different time zone from the Emacs server instance you are accessing remotely via ssh + emacsclient. All clock calculations in that Emacs session are using the local timezone relative to where the server is located. But what you really want is emacsclient to use the current timezone you are in, so things like the mode line clock render accordingly.

To adjust the timezone in an Emacs session, use the command setenv to set the environment variable TZ with a timezone defined in the zoneinfo database. This can be called from Elisp as shown below.

1
(setenv "TZ" "Asia/Seoul")

The latest v3.1.0 update of Casual adds the command casual-timezone-set-tz that provides a completion interface for selecting a timezone to pass to setenv.

1
M-x casual-timezone-set-tz RET

Note that setting TZ impacts the Emacs session globally; any other running behavior depending on a clock should be taken into account.

-1:-- Setting the Timezone in Emacs (Post Charles Choi)--L0--C0--2026-11-12T21:35:00.000Z

Irreal: Let Over Lambda Is Free To Read

Doug Hoyte writes to say that’s he’s making his excellent book Let over Lambda available on line and as a PDF. I’ve written about the book several times most importantly here and here but you can search Irreal for “let over lambda” for the the others.

I can’t overemphasize the effect this book had on me. I learned a lot about Lisp and even programming from it. Some people complained that they didn’t like his approach to structuring his Lisp but I never had a problem with it.

The book is about Lisp Macros and the tremendous powers they provide. As an example, Hoyte gives a macro implementation of the Scheme named let construct. There are a lot more things like that in the book.

Let Over Lambda is about Common Lisp but a large portion of it applies to Elisp too. If you’d like to become really good at Elisp, Let Over Lambda is a good resource. As I said, it’s mostly about Common Lisp but a surprising amount carries over to Elisp.

In any event, you can check out the book for free and if you like what you see, you can read the entire book. It is, believe me, well worth your while.

-1:-- Let Over Lambda Is Free To Read (Post Irreal)--L0--C0--2026-11-12T15:27:40.000Z

Dilip - Zororg: Discovery of Emacs Features

  • This post is my third Emacs carnival entry, this time for Nov 2026. If you're new to this site, FYI I also go by Zororg in emacs chat/universe.

I'm happy that this topic erupted after I poked around in mastodon, maybe some day I'd like to hoist as well.

Before I write up on topic, I'm sure many emacs users might remember that there was a podcast channel called "Discovering Emacs", there was a Youtube channel (rip), mastodon presence in emacs.ch (rip) and everywhere in podcast apps. It was very promising and a professional ambience to hear someone speak of dear emacs. Thankfully git repo exists, and you see the notes and how good it was, wish it had continued or someone brings similar stuff to our small church of emacs. Obviously we are ever so thankful for sacha, protesilaos and emacs-devel people for their good faith and holding up emacs for what it is today even after 50 years.

We need more community users to hold the torch, contribute, volunteer and not be behind the shiny tool-era that is making us lazy and degenerate. Me included!

Back to topic, I usually discovered emacs features based on "good to have" or "cool to have" notion and kept on exploring or adding, sooner came to realize that I've not even grossed the emacs builtins batteries. Nowadays I only discover features based on need, if not it'd be a aha/TIL moment as always.

Emacs is one best example of a perfect software for humans, and by humans. Each object or data is so well connected, that by just using emacs you keep discovering new features every now and then. The docs are the greatest feat of any software that, docs exist for humans and code exists as docs for humans too. History of emacs itself is very funny, thanks for the archives gnu mailing list has and some code has many funny comments, this all brings a smile to users at some point when they again "discover" the legacy of emacs.

Thanks to Alternate Intelligence these days that many people don't recognize the charm of emacs anymore, and thanks to the every busy world that shiny tools keep popping up to be eye candy for all. But for those who recognize or stay, surely emacs got us treat for lifetime. Emacs was almost like Second brain to many users, but now their first brain has been almost replaced by Lazy Learner’s Machine (LLM) and emacs is out of equation now.


  1. How often do you discover an Emacs feature?

    Nowadays rarely, even r/emacs has no human posts, and mastodon #emacs seems to be quite. So for now I'm just getting things done using emacs for my needs. Hopefully could find gems via mailing lists now.

  2. What was the most recent feature that you adopted?

    A consult function to change buffer font by preview. Which is very cool, just like color theme playing with different font is fun to read as per mood. Discovered via r/emacs and hackernews.

    Except for this I've been using ezemstov's fork of emacs which builds pure wayland backend using Skia GPU renderer, without GTK or cairo toolkit. Its snappier and 3-5x snappier than PGTK… read more Its even available in nix emacs-overlay (go try it out with nix shell)

  3. Are you a “Set it and forget it” type of user?

    Most config were that way, but later on trimmed them out and only keep essential ones now. Thats the reason I prefer using builtins now unless necessary. Config is now at 2K LOC.

  4. Do you read Emacs-centric social media trolling for new things to try?

    I wonder where is emacs trolling happening, but I glance actively over r/emacs and #emacs in mastodon, and obviously planet Emacs for all golden nuggets.

  5. What’s the next feature that you’d like to try?

    Canvas patch, IGC, and more than all Gnus upgrade to be async and snappier.

  6. If you’re a Feature Creator, tell us about that!

    Nope, but I've a public config that might be of interest. Also since I was missing two package needs, I tried building those (ofc with help of second brain).

    • nnflux: A Gnus backend reader for Miniflux feeds. It works like a charm with all features for RSS reading beauty.
    • denden: A ox-publish based helper tool to act as typical SSG for emacs, my site that you reading is built using that and I made it just for this purpose to replace hugo.
-1:-- Discovery of Emacs Features (Post Dilip - Zororg)--L0--C0--2026-11-12T00:00:00.000Z

Raymond Zeitler: Creating a Note While org-capture is Active Can Be Confusing

If you invoke org-capture and then create a note1 while the capture is active (as I'm doing now), you might be very surprised when you press C-c C-c to finish the note -- it vanishes!

Don't Panic!

In order to see the note, you'll need to press C-c C-c a second time to complete the capture. Then org-capture adds the item into the Org file, along with the note.

Animation that shows a note started in a capture that then disappears when finished

My preference in this situation is to write only the first phrase or sentence of the note. Then I issue the two presses of C-c C-c and complete the note at its destination. I do this not only to avoid the "scary missing note" scenario; I also worry about leaving work unsaved for any amount of time. The computers I grew up with were prone to crashing at inopportune times, so I adopted the motto, "Save Early; save often." An Org note is composed in the *Org Note* buffer, which has no file associated with it and therefore is not a good candidate for saving.


1 With C-c C-z (org-add-note)

-1:-- Creating a Note While org-capture is Active Can Be Confusing (Post Raymond Zeitler)--L0--C0--2026-11-11T19:04:13.152Z

Irreal: Journelly 1.5

Álvaro Ramírez just announced the release of Journelly 1.5. It’s the formal release of the beta version that I recently wrote about. I can’t say enough about this release. As I’ve said before, my Journelly database is over 4 thousand entries long and before this release Journelly was getting laggy and hard to use but this release resolved all those problems. Now Journelly is as snappy as it was when I had only a few entries and everything about it seems faster and easier.

But wait. There’s more. Ramírez has added an “on this day” feature as well as adding features that make searching for entries by date easier.

If you use Journelly as a journal, you may be interested in the new “on this day” feature. There’s a new button that will show you entries happening on the same day from other years. My particular use case for Journelly is as a memo book so I have no use for this feature. Fortunately, the new Journelly makes it easy to toggle it off if you don’t want it.

The other new significant feature is enhanced searching by date. In the search function you can use on: keyword with several different date formats to search for entries with a particular date. There’s also a calendar button that lets you choose the date from a calendar presentation if you prefer.

You may wonder why I have this entry tagged emacs. I consider Journelly intrinsically linked with Emacs because Journelly keeps its database in an Org file and that means that I can use Emacs and Org mode to search and edit that database. That doesn’t seem like much but I find myself doing it all the time. Journelly has become integrated into my Emacs workflow and become an important part of it.

In the mean time, those of you not in the Journelly beta program now have access to these updates. I can’t speak for Ramírez, of course, but if you’d like to be in the beta program, email Ramírez. He’ll probably be glad to add you.

-1:-- Journelly 1.5 (Post Irreal)--L0--C0--2026-11-11T16:37:06.000Z

Protesilaos: Emacs live ‘pub trivia’ package from scratch today 2026-11-11 at 14:00 Europe/Athens

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

[ The stream will be recorded. You can watch it later. ]

Today I will develop a new package for Emacs. The idea is to have a quiz in a buffer and let the other pick their answer among predefined options. I expect this to take me more than three hours, but we will see.

As usual, I will keep the chat open and shall answer all questions.

UPDATE 2026-11-11 17:34 +0200: I created the Git repository right after the stream and also wrote the backronyms:


🔷 Consider making a donation.

-1:-- Emacs live ‘pub trivia’ package from scratch today 2026-11-11 at 14:00 Europe/Athens (Post Protesilaos)--L0--C0--2026-11-11T00:00:00.000Z

Irreal: Burnish

If you do a lot of exporting from Org Mode and hate all the rigmarole involved, Charles Choi may have precisely what you need. He’s just released Burnish, an app that largely automates the Org export process. The TL;DR is that when burnish-mode is active and a properly marked Org file is saved, the file is automatically exported and a preview is generated.

By default, the app supports exporting to:

  • HTML
  • md
  • odt
  • info
  • LaTeX-PDF

but the app is highly configurable and you can add your own export types and export functions. The app comes with a user manual that explains how to do all this.

If you only occasionally export Org files, Burnish may be more than you need but if you export a lot of Org files, it may save you some time and effort.

-1:-- Burnish (Post Irreal)--L0--C0--2026-11-10T15:39:26.000Z

TAONAW - Emacs and Org Mode: Getting back into journaling: my guide and triggers

I’ve talked about journaling and its importance many times in this blog, but after not journaling for a while I have even more justification for it. At its core, journaling is where my brain grows and gets nourished. Without it, I’m just a dot in time, floating between past and future.

I don’t mean to sound depressing, but think about it. Experiencing life is important, but if you don’t reflect on it, you can’t fully grasp its meaning to you. You can be happy or sad, you can even learn a thing or two, but without having these experiences in front of you for a second pass, where you sit and connect the dots, how much of it can you really retain? If you’re new to journaling or considering it, I suggest you also look into one of my posts explaining its importance.

But let’s drop the philosophical coffee rant for a minute. What I want to get to is my process, after I realized I hadn’t journaled for a while, and the guides I set for myself to help with it.

My tools and techniques may be different from yours, so treat those with the personal flexibility you need. OK, here we go:

  1. Aim to create a journal entry every day. Even if it’s just a list of events in bullet points.
  2. Expand on past events:
    1. Reflect on each bullet point with a few comments of importance. If you feel you’re starting to ramble, be aware of the rest of the list — you can always come back later1 and keep going.
    2. As you go through those comments, try to add the times you did certain things. I use Emacs, so there’s a timestamp structure (a timestamp is a date, followed by a time). It’s a good habit to keep, and it will become useful later.
    3. As your comments expand (or if you revisit later), create additional headings for them when you feel they are detailed enough to merit their own cognitive block.
  3. Look back at your day and even your week, if you wrote it down. Your quick bullet points2 should give you an idea of what you did each day. Is there something you remember now? Is there an additional meaning to something that happened a couple of days ago? Write it down. Reflecting on events like this is exactly what we’re doing here.

A bit of a ramble for Emacs folks (feel free to skip if you’re not one of those):

In Emacs, I also create past events I missed so they show up in my agenda. For example, let’s say I went grocery shopping and made a quick note about it in Journelly. In the evening, when I reflect and write my bullet points and pull my Journelly entries into the main journal (I might expand on this again), I also go to my events org file and write something like “grocery shopping @ Dan’s Fresh Market” along with an approximate time range I was there. The event file is included in the agenda (journal entries are not), and the timestamp shows me when I was there. That’s my quick reflection on what I did and where, when I want it in the future. Since I have the date in front of me, it’s also easy to find the journal entry for that day, since it’s reflected in the file name.

What should be included?

The above is a nice guide on how to write, but it doesn’t tell you what to write. Here is the other part of my quick self-guide. This is more a list of hints that should trigger the “hey, you might want to write about this” bulb in my head, so once again, change it so it fits your brain bulbs:

  • If it’s happening somewhere else (location-based)
  • If it’s happening with someone else (person-based)
  • If it’s something you want to remember (could be developed into a note or a blog post)

In general, this works well. If I leave home and go somewhere, it usually means I want to note it — the same goes when I do something with someone else, even if it’s a dinner at home. The idea to keep in mind is how unusual it is, or whether something different or important happened. As you can see, I left myself a comment that if it’s something I want to remember, I should note it (denote in my case) or turn it into a blog post, as I’m doing right now. Yep, this post is also a journal entry.

Emacs and org-mode are my essential tools when it comes to writing, and this blog is full of posts explaining how I write down things, but I wanted to make this post valuable for other folks as well. Still, I want to emphasize one final note: because Emacs is the best writing tool I have ever encountered, it also means I write more than I ever did before, which in turn means the benefits I mentioned at the start happen on a level that wouldn’t be possible with another tool (at least, not the way I see it). The point is, use something that works for you. Your baseline should be something you don’t think about much, like a reflex. Whether it’s a pocket notebook, quick self-recordings on your phone, or a text file saved somewhere, whatever it is: use it well. Use it often.


  1. This is one of the benefits of journaling digitally: you can easily go back, press Enter a few times, and expand on something. With paper, this becomes harder to do. ↩︎

  2. Expanding on digital vs. paper: on paper, you could write the bullet points first, then below, expand on each event. This will allow you to keep the bullet point list as a quick table of contents, or an index. If you like, you can add quick things to the bullet point itself: an underline below a topic you reflect on below (otherwise you just mentioned it), a star next to something you want to remember. I wrote more about my experience journalling in a pocket notebook, if you want to read more. ↩︎

-1:-- Getting back into journaling: my guide and triggers (Post TAONAW - Emacs and Org Mode)--L0--C0--2026-11-10T14:12:37.000Z

Alvaro Ramirez: Journelly 1.5 released: faster all around

What is Journelly?

Journelly feels like tweeting, but for your eyes only.

A different take on note-taking or journaling for iOS, powered by plain text (Markdown + Org).

  • Save cooking recipes, movies, music, restaurants, coffee shops…
  • Jot down your thoughts.
  • Save your favorite quotes.
  • Use it as a journal, memo book, or notes.
  • Write your shopping lists.
  • Document your travels.
  • Lots more…

If you're an Emacs user, Journelly complements your Org journal file on the go.

Check out journelly.com for details.


download-on-app-store.png
download-on-app-store.png

What's new?

Journelly v1.5's biggest gain is performance. It should bring you an overall snappier experience, especially on larger journals. This release also brings new search features.

Faster with large journals

A user reported migrating about ten years of journaling from Day One into Journelly: over 3,600 entries and thousands of images, converted from a Day One JSON export into Journelly's plain text format. With that much content, typing and navigating became sluggish.

Journelly v1.5 brings a nice round of performance work, so typing, saving, and navigating are now smoother for journals of all sizes. If you're considering a similar move, Journelly should now comfortably handle years of entries.

On This Day

When you have entries from today's date in previous years, a new button appears on screen. Tap it to see what you were up to on this very day, years ago. The little badge shows how many matching entries were found.

Not your cup of tea? Hide the button via "Menu > View > On This Day."

Search by date

Search now understands dates via a new on: filter:

  • on:2024 finds everything from 2024.
  • on:2024-11 finds November 2024.
  • on:November finds every November, any year.
  • on:"November 3" (or on:11-03) finds every November 3rd, any year.
  • on:"November 3, 2024" (or on:2024-11-03) finds that very day.

Dates can be written in your own language too (on:"3 de noviembre", on:"11月3日"), and can be combined with regular search terms and hashtags (on:2024 #travel). Matching dates are highlighted in entry titles.

Pick a date from the calendar

Prefer a calendar view? Tap the calendar button in the search bar to pick a day to search for. Days with entries are marked with a dot, offering a handy way to see when you wrote.

Translations

This release fills in some missing translations and improves the Simplified Chinese (简体中文) text.

Love Journelly? I need your help

Since launch, Journelly has remained a single-payment app. No subscriptions.

That said, sustainable development has been tough without regular downloads, which is why development has slowed down.

Help Journelly grow:

Thank you

Hope you enjoy the v1.5 update.

Thank you for using Journelly and supporting indie development 💛💙❤️

-1:-- Journelly 1.5 released: faster all around (Post Alvaro Ramirez)--L0--C0--2026-11-10T00:00:00.000Z

Amin Bandali: EmacsConf 2026 community panel - my comments

This is a recollection of my comments from the EmacsConf 2026 community panel recording session this past weekend, where the panellists took turns answering the proposed questions, one minute per question per panellist.

In addition to the live Q&A session planned for Saturday 12 December 2026 during EmacsConf 2026, all Emacs users and community members are invited to share their thoughts on the panel questions or other questions before or after the conference.

https://emacsconf.org/2026/talks/community/


1. What made you start using Emacs, and what kept you using it?

I started using Emacs during my bachelor's studies. I actually learned about Vim first and was a Vim user, but I'd always found the configuration language (VimScript) a little bit clunky. Not long after, I discovered Emacs, and really loved reading and writing Emacs Lisp, so I stuck around.

In addition to reading and writing Elisp being fun and enjoyable for me, I love that Emacs has been a practical embodiment of software freedom, and I'm really fond of its surrounding culture of sharing freely. There's a lot to love and appreciate about Emacs, but as a practical personal example, I've been grateful for its excellent support for bidirectional text editing. It has empowered me to read and write in Persian, my mother tongue, with ease. (Persian has a right-to-left alphabet, like Arabic and Hebrew.)

2. What took you from using Emacs to actively contributing to the community - participating in forums, writing Elisp, organizing meetups, answering questions?

As I continued experimenting and writing bits and pieces of Elisp to scratch my own itches, I felt compelled to share them freely as a way of giving back to the community that gave me so much.

For me, the community and the people that make it up are the main deal. Emacs wouldn't be where it is and what it is today without its people, so besides programming contributions, I've tried to contribute in that area as well, for instance by reviving EmacsConf with Sacha Chua back in 2019.

3. How does Emacs show up for you in real life - colleagues, meetups, friends? How did those connections form?

I don't physically have people near me who use Emacs, but I've connected with many folks in our online communities, often starting with an email or IRC message. Some of those relationships started as acquaintanceship and were developed into true friendship over time, and I'm grateful to have had those friends with me.

4. If you know other software communities, what's one thing Emacs could learn from them?

I would encourage Emacs, our community, to focus on the people. We're living in particularly difficult times, with various kinds of hardships and uncertainty in our lives. Let's strive to treat each other with kindness, empathy, and mindfulness as we continue working together.

There are great examples of other free software communities whose members have banded together and are strengthening each other and their community, as well as cautionary ones where community members have been tiring and driving out their fellow members. We could learn valuable lessons from both in how to take care of our people and ourselves.

5. What's one concrete thing you wish existed in the Emacs community a year from now?

I echoed the sentiments of my fellow panellists Prot and Til about doing more of the same in terms of continuing to uphold the standards of excellence and perseverance. Also, drawing inspiration from what bashbunni said, to lower the barriers of entry for people, for example through organizing different kinds of events, and experimenting with ways to make people's lengthy, elaborate Emacs configurations more tangible and accessible to others, to share various workflows and demonstrate what's possible with Emacs.

I look forward to your thoughts on these and other community-related questions.

Take care, and so long for now.

-1:-- EmacsConf 2026 community panel - my comments (Post Amin Bandali)--L0--C0--2026-11-09T21:57:44.000Z

Curtis McHale: Discovering Emacs Features - November Emacs Carnival

The Emacs Carnival topic for November is: Discovery of Emacs Features.

How I Discover Features

My biggest new feature discovery method is Emacs News. Normally I'll clear every other item out of my RSS feeds and then dedicate a single reading session to reading Emacs News because I open up so many links to read that it needs its own dedicated session.

Being fairly new in my Emacs journey I find new interesting features all the time, my biggest issue is the time to add them to me workflows. I've been in Emacs long enough now that I dream of being able to move most of my work into it. I open Obsidian to write and wonder why I'm not writing in Emacs. I have Kitty open and wonder why I don't just use Emacs?

There is so much to learn in Emacs, and so many things it could replace I'm sort of stuck wondering where to even start.

The newest feature I'm trying to wrap my head around is workspaces. I'd like to retire Kitty and Zellij to focus on Emacs, but navigation in Zellij is so ingrained in my muscle memory I need to find some way to make it that seamless in Emacs, and I haven't quite found it yet.

-1:-- Discovering Emacs Features - November Emacs Carnival (Post Curtis McHale)--L0--C0--2026-11-09T19:53:00.000Z

Marcin Borkowski: A tip on removing functions from hooks interactively

When I customize my Emacs, I often utilize hooks. However, when experimenting, I often inadvertently add the wrong thing to a hook – a function I later decide to rename or even a lambda. I have always painstakingly written the correct remove-hook invocation to do it. A few days ago it occurred to me that it would be nice to write an interactive wrapper around remove-hook to make it easier. As usual in such cases, I started with a bit of research to see if someone did something similar already. To my surprise, not only is this a solved problem, but it’s solved in Emacs itself! Apparently, almost six years ago remove-hook was made into a command and you can just M-x it, provide the hook variable name and use autocompletion to decide what to remove from it (including lambdas!). How cool is that?
-1:-- A tip on removing functions from hooks interactively (Post Marcin Borkowski)--L0--C0--2026-11-09T18:41:00.000Z

Charles Choi: Announcing Burnish

Org mode is often celebrated for its ability to “write once, export anywhere.”

With such power comes added complexity: Exporting a file requires the user to typically go through a multi-step process (e.g. C-c C-e <some char> <some other char>). If the user is concerned with previewing changes to their file, then another step of viewing the exported output is required. Having to do this repeatedly gets tedious fast. Such is the motivation for Burnish.

Burnish is a new Elisp package I’ve made to automate the export and viewing of an Org file. It provides an Emacs minor mode (burnish-mode) that when enabled, does the following upon save of an Org file:

  1. Export the Org file to a specified export backend.
  2. View the exported output in another Emacs window or by external tool.

Most all of the default backends provided by Org mode are supported by Burnish. That said, Burnish is highly configurable, allowing for users to define for themselves the export and view workflow for existing or third party backends.

Read the Burnish User Guide to learn more about it. As it is new, feedback is always welcome. If you really find it useful, please show your gratitude by buying me a coffee.

Burnish v1.0 is now available on MELPA.

-1:-- Announcing Burnish (Post Charles Choi)--L0--C0--2026-11-09T16:15:00.000Z

Irreal: Emacs 31.1.90 Pretest

More good news on the Emacs front. Sean Whitton writes to say that the Emacs 31.1.90 pretest is available. The Emacs point releases are generally to fix bugs and maybe refine an existing functionality but you shouldn’t expect any major new features. That will have to wait for Emacs 32. As always, the developers are asking for our help to test the release and let them know if we encounter any problems building or using it.

Be aware that there are some typos in Whitton’s post. In the first place, the pretest will eventually become Emacs 31.2 (not 31.1). More importantly, there are also typos in the URLs for the release. The correct URL is https://alpha.gnu.org/gnu/emacs/pretest/emacs-31.1.90.tar.xz and similarly for the signature file.

My usual thanks to the Emacs developers who work so hard for us and give us so much. As I always say, if one of us finds ourselves in the same bar as one of the devs, we’re buying.

-1:-- Emacs 31.1.90 Pretest (Post Irreal)--L0--C0--2026-11-09T15:23:59.000Z

Sacha Chua: 2026-11-09 Emacs news

: Added EmacsSF this Saturday.

The Emacs Carnival theme for November 2026 is Discovering Emacs features. Thanks to Raymond Zeitler for hosting. Looking forward to reading your thoughts!

There is a very long discussion about Human Emacs and LLM-assisted contributions on emacs-devel. It is a lot. I don't want to throw fuel on the fire. I'm mentioning it because it's a topic that a lot of people care very strongly about, and because there's a subdiscussion about slavery that might ripple out into the wider community. If you do decide to weigh in, please be kind and thoughtful. Thank you!

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

View Org source for this post

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

-1:-- 2026-11-09 Emacs news (Post Sacha Chua)--L0--C0--2026-11-09T12:56:50.000Z

Tony Zorman: LaTeX Previews for Elfeed

9th Nov 2026–11th Nov 2026 · 3 min read · #emacs

LaTeX Previews for Elfeed

Org’s new LaTeX preview system is out—time to celebrate! Not only does this mean that one can now enjoy reasonable previews without having to use a forked version of Org, but given that we are using the infinitely extensible text editor, this preview functionality can be used virtually everywhere. Let’s hack it into elfeed.

While its creator seems to disagree, I still believe that elfeed is by far the best feed reader in existence.1 As RSS feeds are so static, it also feels like the ideal candidate to get a feeling for adapting org-latex-preview to other major modes.2

Previewing LaTeX is quite important when one is subscribed to arXiv’s feeds,3 as titles and descriptions obviously contain maths sometimes:

The only function that we’ll need to get these previews working is org-latex-preview-place. It has two mandatory arguments, processing-type and entries. The latter is just a list of buffer positions (beg end) in which to find the LaTeX fragments, while the former sets the type of transformation you want to use.4 This means that the main thing we have to do is to collect all of the fragments:

(defun elfeed-latex-preview ()
  "LaTeX preview the current elfeed buffer."
  (interactive)
  (save-excursion
    (with-syntax-table (copy-syntax-table)
      (modify-syntax-entry ?- ".") ; $x$-y is valid
      (when-let* ((entries
                   (cl-loop
                    for (_ re pos _) in org-latex-regexps
                    append (cl-loop
                            initially (goto-char (point-min))
                            while (re-search-forward re nil t)
                            collect (list (match-beginning pos)
                                          (match-end pos))))))
        (org-latex-preview-place 'dvisvgm entries)))))

The cl-loop code is so close to natural language that I feel like it should be obvious even if you’ve never seen such a loop expression. The only thing that’s slightly tricky is that Org doesn’t really recognise constructs of the form $x$-y as valid LaTeX—as far as I know because it conflicts with one of its million syntax rules. To hack around this, as I still want to use org-latex-regexps,5 we can treat the dash as punctuation while looking for fragments, since a punctuation character following the closing dollar is permitted.

To hook this function into elfeed, we can simply check if the arXiv view is selected in either elfeed-search-mode or elfeed-show-mode, and then just call elfeed-latex-preview on the buffer:

(defun elfeed-latex (&rest _)
  (when (or (string-match-p "arXiv" elfeed-search-filter)
            (and elfeed-show-entry
                 (memq 'arXiv (elfeed-entry-tags elfeed-show-entry))))
    (elfeed-latex-preview)))

(add-hook 'elfeed-search-update-hook #'elfeed-latex)
(add-hook 'elfeed-show-update-hook   #'elfeed-latex)
(advice-add 'elfeed-search-update-entry :after #'elfeed-latex)

As the names suggest, the two hooks are for when things change in elfeed-search-mode and elfeed-show-mode, respectively. The hooks for entering those major modes seem to run too early for LaTeX previewing to have any effect. The advice is needed since opening a feed entry with elfeed-search-show-entry does update and redraw its title (e.g., marking it read), but sadly elfeed bypasses the usual search-update machinery, and thus this doesn’t activate any of the required hooks.

Pretty feeds, at last.


  1. Certainly better than a vibecoded C++ GUI thing…↩︎

  2. Not that it makes much of a difference; the API as I see it is essentially plug-and-play.↩︎

  3. If you can stomach the arXiv in 2026, that is. I know enough people who’ve just given up at this point, and are just scanning whose name they recognise. While this usually is a good way to filter out slop, it’s honestly quite worrying—but that’s not what this post is supposed to be about, so let’s stop here.↩︎

  4. dvisvgm, dvipng, or imagemagick, at the time of writing.↩︎

  5. Yes, the subset of TeX allowed in arXiv titles and descriptions is so minimal that one could probably get away with manually curated regexps. However, this would result in more code, so this approach seems simpler. It also has the nice benefit that some people don’t care what the arXiv allows or not, and will use \(…\)-style brackets, even though those are not rendered on the website.↩︎

-1:-- LaTeX Previews for Elfeed (Post Tony Zorman)--L0--C0--2026-11-09T00:00:00.000Z

Lars Ingebrigtsen: OK, OK, I’ll just use tmdb

After last night’s post, I realised I was probably just getting too invested in somehow using imdb for the “who’s that actor, anyway?” command for my Emacs-based video player.

Not only is it an extremely fragile setup that’s gonna stop working, but it’s also very slow — it takes half a minute to return the actor profile images.

So I just implemented a tmdb API shim and then I ask it for the actor profile photo instead. tmdb doesn’t have as large a data base, but… The API is free (for non-commercial use) and is extremely easy to use.

Things are now faster:

The main wait is from the response from the LLM — I’m using gemini-3.8-flash. I’ve tried gemini-3.1-flash-lite, and it’s much faster… but gives the wrong result most of the time. No, that’s not Roy Scheider, Gemini!

So now the setup is less Rube Goldberguesque. Sort of:

  1. I hit a key on my li’l wireless keyboard.
  2. It’s picked up by a Python script that listens for evdev events.
  3. It uses emacsclient to notify the Emacs running on the TV machine.
  4. Emacs there tells mpv to do a screenshot.
  5. Emacs waits until the screenshot arrives on disc.
  6. Emacs sends it to Gemini and says “who dis? JSON please”.
  7. Gemini responds and Emacs then creates an SVG overlay with the actor name.
  8. rsvg-convert converts to PNG and then imagemagick convert to BGRA.
  9. Emacs asks mpv to display it.
  10. Emacs asks tmdb for the actor profile URL and fetches the image.
  11. If it gets a response, it then recreates the svg with the image embedded.
  12. (repeat 8-9).

Couldn’t be simpler.

-1:-- OK, OK, I’ll just use tmdb (Post Lars Ingebrigtsen)--L0--C0--2026-11-08T11:48:11.000Z

Protesilaos: EmacsConf 2026 community panel comments I made

The following is my recollection of comments I made during the recording of the EmacsConf 2026 community panel (the Q&A session will happen live during the conference): https://emacsconf.org/2026/talks/community/.

It is not a transcript though it is true in spirit.

We had 1 minute per answer.

Starting with Emacs

1 What made you start using Emacs, and what kept you using it?

It is the potential of interconnectedness. With Emacs I can draw linkages between different parts of my workflow, such as from the email client or RSS feed reader to the agenda. It also is the transferability of skills: when I write a custom function that works, say, for programming then that same function can be used while writing emails (e.g. a “focus mode” that also enlarges the font size and switches the cursor from a box to a bar shape). Software freedom is another important consideration because it empowers me to do my personal computing as I want and Emacs is by far the best in this regard.

Contributing to Emacs

2 What took you from using Emacs to actively contributing to the community - participating in forums, writing Elisp, organizing meetups, answering questions?

One is organic. By using Emacs, I configure it by programming it. The more I do that, the more I learn how to write Emacs Lisp. I eventually reach a point where I can produce patches for existing libraries and also develop my own packages. This organic growth blurs the lines between user and developer as well as passive user and active contributor. The other part is a sense of stewardship. I am inspired to give back to the commons. I recognise that I benefit from the freedom I receive and thus assume the duty of empowering others to do the same.

Emacs in daily life

3 How does Emacs show up for you in real life - colleagues, meetups, friends? How did those connections form?

I talk to Emacs users on video calls. I have even met a few in person who wanted to visit me for other reasons as well (one case was a funny story about “a Greek philosopher who is actually alive”). Those connections form naturally over time. I find that there is concordance of spirit. People who use Emacs have some character traits in common. I can see a little bit of myself reflected in them and a little bit of them reflected in me. Each person has their individuality. Though we all answer a certain call that compels us to explore the depths and the lengths.

Learning from other communities

4 If you know other software communities, what’s one thing Emacs could learn from them?

I think this is not specific to software. What is true for the Emacs community is true for communities in general. It is about the potential for participation. People must feel that they are part of something greater than themselves; something that will be there even after they are gone. Thriving communities create involvement through a variety of means and thus engender the belief that one can move from the notional periphery to the centre, from observer to member. Concretely, livestreams, bug squashing events, social gatherings, virtual or in-person conferences, and even face-to-face meetings, all help create a sense of belonging and togetherness.

What to change for next year

5 What’s one concrete thing you wish existed in the Emacs community a year from now?

Uphold the standard of excellence. Keep doing what we do and increase it in intensity and/or frequency wherever possible. Those who chase fads have a spectacular rise followed by an equally spectacular fall. What has made Emacs—and communities in general—stand the test of time is unflinching commitment to their core tenets. Those are the qualities that made them interesting in the first place. In practice, this is about focusing on quality and letting the quantity come about organically. People come and go. To prioritise quantity is to attract opportunists and, in the process, to erode the soil we stand on.


🔷 Consider making a donation.

-1:-- EmacsConf 2026 community panel comments I made (Post Protesilaos)--L0--C0--2026-11-08T00:00:00.000Z

Lars Ingebrigtsen: Who’s That Actor? Revisited

I was watching The Four Seasons yesterday, and there were a couple of actors I wondered who were. I mean, not Alan Alda, but a couple of the others… so I hit the “Emacs, tell me who what is” button on my remote, and nothing much happened.

So things had bitrotted once again, which isn’t weird — the code is a bit of a Rube Goldberg thing which you can peruse here, but I wouldn’t really recommend it.

But I’ve spent the entire day fixing it, so I deserve to complain aimlessly in a blog post, right?

OK?

OK: The main problem is that AI web scrapers are hitting imdb so hard that Amazon has tightened its shield even more. The main motor behind the Actor Guessing Machine is an LLM, and that API still works (if you can call “being wrong half of the time” to “work”), but I’m trying to use imdb to show the actor’s face (see inset on the top right above) so that I can check whether what the LLM said is likely.

My first idea was to just avoid using imdb altogether. Instead I asked the LLM to include an image of the actor, too. Shouldn’t be too hard, right? Well, Gemini will do this if you ask — but it takes 45 seconds or so. Yes! 45 seconds! So that’s not very UX-ey.

I also tried using Claude, but it sternly told me that I was very naughty for even trying to make it output images of real people, and that I should be ashamed of myself. Oh, and then also (since I had asked it to return JSON and nothing else), it also included this in the middle of the rant:

```json
[]
```

🤷

So… Back to imdb: I’m already using a headless Chrome to fetch imdb data, but now it requires popping up Chrome (once in a while) to click on some hats or something:

How elegant! I’m so proud of the UX!

So what I’m doing is running a “server” (Emacs based, of course) on the laptop, and when the TV computer needs to get some imdb data, it (Emacs) asks the laptop (Emacs), and if it then turns out that it needs to pop up a window, it can do so (Chrome).

*sigh*

So… it’s all a bit stupid. And is it worth it? Eh. It’s probably gonna break in a few weeks anyway. I guess I’m more offended that I have to do this much work more than anything else. The challenge? Eh. Dunno.

But when it doesn’t need a popup, it’s kinda OK:

See? So… eh.

Oh, and while I’m moaning and carrying on:

LLMs are still guessomats. I ask the LLM (Gemini, in this case) to include the imdb ID of the actor in the response, and it will totally just make up an ID. So that’s not Carol Burnett in the inset image there.

And is that really Alan Alda?

That’s definitely not Alan Alda.

I guess that could be Alan Alda.

Anyway, since Gemini just makes up imdb IDs, I’m instead resorting to using the imdb data dump — when I get “Alan Alda” back from the LLM, I then look up the name in the imdb data dump database (that I have locally) and use that instead. If the name is spelt differently there than what Gemini returned? Well, them’s the breaks.

So this is totally a toy, but it’s kinda useful anyway.

-1:-- Who’s That Actor? Revisited (Post Lars Ingebrigtsen)--L0--C0--2026-11-07T20:30:49.000Z

Irreal: BYOK

My ex-colleague and old friend Watts Martin has an interesting post about BYOK. BYOK is a “writer deck”, a device exclusively for writing that has no distracting apps or even a connection to the Internet. The idea is that writers can’t get distracted when they reach a temporary block by escaping to social media or something similar; they have to push through the block and get on with their writing.

According to Martin, BYOK is better than most devices in its class but there are still problems. He doesn’t like the available fonts and the screen—as you can see from the picture in his post—is pretty small, about 6 lines depending on the font. That seems to me to amount to a rather uncomfortable working environment. Fortunately, I don’t usually find myself distracted when I’m writing.

Then there’s the matter of research. Very often you need to look something up when you’re writing and you can’t do that with something like BYOK so you need to switch devices, pulling you even further out of the flow. And as Martin observes, it’s not easy to integrate your notes either.

The deal buster for me, though, is the builtin editor. It’s not Emacs based and doesn’t even support Emacs keybindings for navigation. As I’ve repeatedly said—as recently as yesterday—I simply can’t comfortably write outside of Emacs anymore. Martin is a relative newcomer to Emacs but he’s already feeling the discomfort. Once the Emacs way sets in, he’ll be just like me and won’t consider doing serious writing outside of Emacs.

Even if I were subject to being distracted by the greater Internet, I would simply turn off my WiFi to produce what is effectively an Emacs based writer deck. One thing for sure, I’m not giving up Emacs and suffering a second rate writing environment.

-1:-- BYOK (Post Irreal)--L0--C0--2026-11-07T16:02:24.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!