Currently I have this as a general setup: (setopt completion-at-point-functions (list (cape-capf-super #'cape-keyword #'cape-file #'cape-dabbrev))) and this as a setup for eglot-enabled buffers: (setq-local completion-at-point-functions (list (cape-capf-super #'eglot-completion-at-point #'cape-keyword #'cape-file #'cape-line #'cape-dict)))

According to what I could find, the capf variable is supposed to be a list in order of completion priority, but setting it to anything except a singular capf (either normally or via cape-capf-super) either breaks completion-preview completely or at least breaks the overlay part of it. Is there a better way of doing any of this? I was specifically looking to have completion for LaTeX commands via AUCTeX but I couldn't get it working consistently.

I've been working on Supertag, a package that treats tagged Org headings as typed nodes (tags with fields, queries, backlinks, streams). 0.4.0 adds the piece I've wanted for a while, and I made a short video about the idea behind it.

The problem I kept hitting. Asking an LLM to make small edits to my notes ("I talked to X today, log it") works most of the time. Only most of the time, so I end up opening the note to check, almost every time. Checking costs about as much as doing it by hand.

What 0.4.0 does instead. You open a tag's Stream (a time-ordered list of its nodes) and describe in one sentence how it should work, e.g. "group people by how close we are, and give me a key to log that we talked today."* A model writes a small Elisp agent for that Stream: groups, a line per note, and keys that write properties. After that the agent runs with no model call. Pressing the key writes :LAST_CONTACT: 2026-10-26 into the property drawer, as plain text. `R` revises the agent with another sentence.

Some boundaries I care about, which I suspect this sub does too:

- The Org files are the only truth. The Stream is a view. Agents never create notes; they only read and write declared properties (and `SCHEDULED`/`DEADLINE` if you ask for dates). Delete an agent and nothing in your files changes.

- The model only runs when you ask: when designing or revising an agent. Nothing calls a model in the background.

- Generated code is checked before install. It is built from a fixed set of primitives; every field an action writes has to be declared; the view must place every note in a group, draw a single-note stream, and redraw after each action. Failures go back to the model, up to a limit. You can read the code with `C`; the sentence and its revisions are kept as comments.

- Bring your own model. Requests go through gptel (with a `supertag` preset) or Superchat. Local models via Ollama / LM Studio work.

The idea is borrowed from Lifestreams (Eric Freeman's 1997 Yale thesis): one stream of everything, substreams by query, and processors on top. Its processors had to be written by hand (a phone-call agent took ~150 lines of Tcl), which is why they never spread. An LLM can be that author, once.

Also in 0.4.0:

- `M-x supertag-view-stream` opens one stream of all nodes; `f` narrows with plain words, `tag:prj`, `KEY:VALUE` or a full query; `u` goes back.

- Discovery adds results by meaning after keyword matches (embeddings via Ollama or any OpenAI-compatible endpoint; off by default).

- Agents can indent tasks under their project, using the outline path.

- Archived notes (`ARCHIVE` tag, `org-archive-location`, denote `archive` keyword) are hidden from streams; `A` shows them.

- denote `#+IDENTIFIER:` and `:ID:` file headers are file nodes by default.

Repo: https://github.com/yibie/supertag

Release notes: https://github.com/yibie/supertag/releases/tag/v0.4.0

Requires Emacs 29.1+, Org 9.6+, textui 0.9.0. After upgrading, run `M-x supertag-sync-full-rescan` once.

The demo uses a made-up vault; the narration is a synthetic voice. Happy to hear where this breaks, and what you'd want an agent to do for one kind of your notes.

UPDATE:
fixed chapters to give a better idea of the topics
Added youtube video description as some sort of a TLDW

Good day emacs gang! I bring you a video of one of the Emacs Messiahs.

I had Protesilaos on Root Access, my members' podcast, with a couple of my members, Rumen and Ted. Rumen recently switched to Emacs full time, so this one leans heavily Emacs even though I'm a Neovim guy.

Some of what we talked about (chapters):
00:00 Highlights
01:17 Why Prot joins Root Access to balance out Neovim
07:37 Can you live off Emacs coaching? Prot on austerity
12:52 From a rented donkey stable to building Prot's own hut
18:50 Why everyone wants to move to Cyprus
24:36 Emacs 31 newcomers presets and how Emacs development works
31:12 Prot on the anti-AI Emacs manifesto and community politics
36:15 Prot on AI: programming is fun, but the market decides
42:03 Rumen learning Emacs with AI and Prot's coaching
48:07 Rumen's plan for a NixOS and Emacs centric machine
53:01 Techieman's Emacs journey on pause due to workload
59:42 Why Prot skips Hyprland: bling is an anti-feature
1:03:55 Omarchy, DHH and separating the work from the author
1:10:56 Sessions with Prot and sponsoring open source maintainers
1:16:19 Real Emacs on Android via F-Droid and iSH on iPhone
1:20:10 Why linkarzu won't switch back to Emacs yet
1:26:33 The spirit of Emacs is integration, not the software

It's the full conversation with chapters, about 90 minutes:
https://youtu.be/dQ6X0-XCLIw

Happy to hear what you think, especially from those of you who've gone back and forth between Emacs and Neovim.

YouTube video description:
After all my Neovim talk, Rumen brought Protesilaos (Prot) onto Root Access to balance things out, and Ted joined us too. Rumen shares that he converted to Emacs full time, is building a NixOS flavor, runs his tasks in Org mode, and is working on a small database server so the notes he dictates on his phone sync to Emacs on his desktop and laptop. We also get into the anti-AI "Human Emacs" fork idea, and Prot explains why Emacs already refuses LLM-generated contributions over copyright and GPL licensing concerns, and how maintainers spot suspicious patches. Prot says he doesn't use AI because programming is basically his video game, but he admits the technology case is undeniable and frames the AI bubble as a capital realignment like the dot-com crash.

We also talk about how Cyprus and Greece export tourism and land, and the gold rush mentality that comes with it, and I ask Prot about Cypriot olive oil for my wife. Then it's Niri and scrolling window managers versus i3/Sway-style control, Emacs workspaces replacing tmux, and DHH's Omarchy, where Prot argues software should be judged on its merits and not its author, and explains why he refuses to remove a Modus theme port for Omarchy. I show Hazenbug's org mode plugin for Neovim, Prot explains why org is portable plain-text markup, and I explain why I'm not switching back to Emacs yet - I'm not on the Neovim team or the Emacs team, and editor choice shouldn't be treated like soccer or religion. If you care about Emacs, Neovim, free software, or how AI fits into all of it, this one is for you.

Both apps are running side by side on a Pixel Tablet in split screen.

On some taps one side responds about 0.1–0.5 s later than the other, most visibly when opening a note.

B (right) is Emacs Lisp. It runs in GNU Emacs 31 for Android on the tablet itself, with no desktop and no network. The Orgzly screens, menus, dialogs and the Org file editing are an Elisp applet. It describes each screen as JSON and sends it over a local socket to Jetpacs, a generic Jetpack Compose renderer. Very similar to how Google's A2UI protocol works. The renderer contains no Orgzly-specific code. The date, time and repeat pickers are Android's own widgets on both sides; the Elisp side asks the renderer for them.

The lag is the Elisp → renderer round trip. Raising Android Emacs's gc-cons-threshold from the default 800 KB to 64 MB and byte-compiling the Elisp cut a screen update from about 490 ms to about 28 ms on the tablet. It will always be slower because it always requires a round trip to Emacs for any application logic.

https://github.com/calebc42/orgzly-native

region-cursors is a minor mode that adds cursor-like overlays at both the point and mark when a region is active.

On MELPA and MELPA Stable. Feedback and PRs welcome!

Hello emacs people. I've kept my notes in org mode in Emacs for over a decade, but reading them or making small edits on my phone has always felt clunky. So over the last year I built an Android app to fix that. I have been using it daily and adding features and fixing bugs for almost a year now. I'm biased, of course, but I find it a pleasure to use. (It handles markdown and plain text too.)

I posted an early version here once before. Since then I've made a lot of bug fixes and added features.

I won't give my spiel here and will let the video do the talking, but I'll be watching the comments and happy to answer questions.

If this looks useful to you, see my comment below to join the beta. I'd love to reach the tester threshold so I can publish it on the Play Store.

Scott

I've started running flymake on elisp files like init.el which gives me an easy way to find stray typos that I tend to leave around quickly.

The big issue with doing so is you need to make the whole file clean with respect to its usage of external functions and variables in other packages.

For me that was a huge block of declare-function, defvar statements.

For now I stuck them in a separate file and have a small macro to pull them in when compiling

(eval-and-compile
  (defmacro my-include-declarations ()
    "Expand to the forms in lisp/compile-declarations.el, or nil when not compiling."
    (when (bound-and-true-p byte-compile-current-file)
      (let ((file (expand-file-name "lisp/compile-declarations.el" user-emacs-directory))
            forms)
        (with-temp-buffer
          (insert-file-contents file)
          (goto-char (point-min))
          (condition-case nil
              (while t (push (read (current-buffer)) forms))
            (end-of-file nil)))
        `(progn ,@(nreverse forms))))))
(my-include-declarations)

I'm curious if anyone has a cleaner solution to this type issue where less predeclarations are needed optimally.

*More context: I'm also using elpaca.

Hi all!

I've been using emacsforosx builds for years since I have been using emacs for almost everything since 1987 but I'm not a programmer or systems guy (ASIC design mostly using SystemVerilog, Python, MATLAB, and BASH).  I've built emacs from scratch a couple of times but when I start getting library errors I quickly get in over my head!

I just got a new M5 Macbook Pro (running 27.2 beta 3) and went to install the latest emacs 31 and my init.el blew up.  Doing some web searches, it looks like all the elc/native-compile broke. This makes sense since it's an ARM and I probably last compiled for x64.  So, I deleted my eln- directory to rebuild everything.  I'm sure you know what happened next.  A ton of elisp errors and warning including this in *Native-compile-log*

Compiling /Users/david/.emacs.d/eln-cache/31_1-032f33bc/subr--trampoline-72656e616d652d627566666572_rename_buffer_0.eln...
clang: error: invalid version number in '-mmacosx-version-min=18.0'
libgccjit.so: error: error invoking gcc driver

debug-early-backtrace...done
Internal native compiler error: "failed to compile", "/Users/david/.emacs.d/eln-cache/31_1-032f33bc/subr--trampoline-72656e616d652d627566666572_rename_buffer_0.eln", "error invoking gcc driver"

Error: native-ice ("failed to compile" "/Users/david/.emacs.d/eln-cache/31_1-032f33bc/subr--trampoline-72656e616d652d627566666572_rename_buffer_0.eln" "error invoking gcc driver")
  comp--compile-ctxt-to-file0("/Users/david/.emacs.d/eln-cache/31_1-032f33bc/subr--trampoline-72656e616d652d627566666572_rename_buffer_0.eln")
  comp--compile-ctxt-to-file("/Users/david/.emacs.d/eln-cache/31_1-032f33bc/subr--trampoline-72656e616d652d627566666572_rename_buffer_0.eln")
  comp--final1()
  load-with-code-conversion("/private/var/folders/s5/zfnmhf0n5dzb3_7k13w83pc00000gn/T/emacs-int-comp-subr--trampoline-72656e616d652d627566666572_rename_buffer_0-Za7a4a.el" "/private/var/folders/s5/zfnmhf0n5dzb3_7k13w83pc00000gn/T/emacs-int-comp-subr--trampoline-72656e616d652d627566666572_rename_buffer_0-Za7a4a.el" nil t)
  command-line-1(("-l" "/var/folders/s5/zfnmhf0n5dzb3_7k13w83pc00000gn/T/emacs-int-comp-subr--trampoline-72656e616d652d627566666572_rename_buffer_0-Za7a4a.el"))
  command-line()
  normal-top-level()

I should mention that I have OSX set to bash instead of the default zshell since that's what I'm used to from Linux.  

So, I started looking at my Homebrew and realized that was also all x64 so I totally uninstalled and re-installed it and did brew install gcc and libgccjit.  I found this info online. I guess a lot of people hit this in emacs 31!

(defun setup-macos-native-comp-library-paths () "Set up LIBRARY_PATH for native compilation on macOS." (setenv "LIBRARY_PATH" "/usr/local/Cellar/gcc/15.2.0:/usr/local/Cellar/libgccjit/15.2.0/lib/gcc/current/:/usr/local/Cellar/gcc/15.2.0/lib/gcc/current/gcc/x86_64-apple-darwin24/15"))
(setup-macos-native-comp-library-paths)

I did this, changing /usr/local to /opt/homebrew and version 15 to 16, which is what brew installed. I added this to the head of my init.el and restarted emacs but it didn't seem to help. I'm now getting beyond my knowledge and not sure what I'm doing or how to troubleshoot. And even after all of this, I'm sure going from emacs 30 to 31 is going to break a bunch of my init.el and packages. I just want to edit some files!

Any ideas? I see recommendations for brew/emacsplus. Should I switch to that?

Thanks much!

How to colorize/format paths displayed by Veritco (e.g. from Consult) to make them visually easier to read? I add a custom source to consult-buffer to include Emacs config and org files:

(defvar my/conf_and_org_files_source
  `(:name "Emacs config + Org files"
          :narrow   ?d
          :category file
          :face     consult-file
          :state    consult--file-state
          :items    (lambda () (let* ((base-dir user-emacs-directory)
                                      (elisp-dir (expand-file-name "elisp" base-dir))
                                      (el-regexp "\\.el\\'")
                                      (files nil))
                                 (setq files (directory-files base-dir t el-regexp t))
                                 (setq files (append files (directory-files-recursively elisp-dir el-regexp)))
                                 (setq files (append files (org-agenda-files)))))))

(with-eval-after-load 'consult
  (add-to-list 'consult-buffer-sources 'my/conf_and_org_files_source 'append))

The results are e.g.:

/home/user/.config/emacs/custom.el
/home/user/.config/emacs/early-init.el
/home/user/docs/notes/todo.org
/home/user/docs/notes/archive/todo.org

I would like to e.g. use ~ instead of /home/user, highlight / path separators, different colors between the basename of the file and the rest of the path, and maybe even shorten like ~/.c/e/custom.el. Or show the basename first, e.g. custom.el ~/.config/emacs (with column alignment)--this would be preferable for my set of files. As-is, it's not so easy to read, especially if files are deeply nested and all over the filesystem.

Any examples are much appreciated, not a programmer (also feel free to suggest refactoring the above like avoiding multiple variable assignments).

As Emacs does more and more duty as a front-end for various agent interactions, I am dealing with more and more large buffers. For instance, long conversations via gptel or the Hermes Agent (name: hermes) on Non GNU Elpa. Particularly for Hermes Agent where I might have dozens of open sessions on various topics and each of them could run over the course of many days. I'm noticing some slow downs on a pretty beefy workstation regardless of CPU or memory.

I suspect that folks who do things like read email or do instant messaging in Emacs might run into similar?

For anyone doing any of the above, how are you dealing with very large buffers? I have a dozen that are nearly 10k lines.

Perhaps newer versions of Emacs will move toward not keeping the entire buffer in memory at all times? I believe I have read that that has been the model for a long time.

Yo! I spend a lot of time in Org mode and often want to do quick and simple calculations directly in prose. Org tables are overkill for simple stuff. For example, I'd like to turn this:

The overall costs were 300 + 400.

into this:

The overall costs were 300 + 400 = 800.

Ideally, I'd place point somewhere in the expression and invoke a command that evaluates it and inserts the result. Is there an existing built-in solution, or is a custom function the usual approach?

welkomscherm.el: a configurable list of thunk handful of lines, the links you actually use, and nothing that gets in your way, but extensible enough for you.

Source: https://codeberg.org/jjba23/welkomscherm.el

It works well in graphical frames and in CLI too on any Emacs >= 25.1

  (setopt welkomscherm/sections
          (list welkomscherm/top-title
                ;; A section of your own, built as a record.
                (welkomscherm/make-section
                 :name "Today"
                 :condition (lambda () (bound-and-true-p org-agenda-files))
                 :render (lambda () (welkomscherm/insert-muted "Make it a good one.")))
                ;; Or just a bare function.
                (lambda () (welkomscherm/insert-muted "and a warm cup of coffee"))
                welkomscherm/bookmarks
                welkomscherm/actions))

Hi, I've recorded a video on mTLS, in which I write an mTLS server in Go using Emacs. The Emacs bit starts 10:18 into the video and runs for about 14 minutes.

You can see Emacs delivering an excellent coding experience, using eglot and gopls:

• code completion
• code actions
• code navigation
• linting
• documentation lookup
• running commands from inside Emacs
• version control with Git using Magit
• running a terminal inside of Emacs

I hope it might be of interest to some of you.

mtls #tls #security #golang #emacs

I'm looking for themes with near-white backgrounds that use grey to black fonts for syntax-highlighting etc?

I have checked out a few and come across Almost Mono White, Doom Homage White, Eziam Light and Real Mono Eink and the recently announced Foxglove Themes.

I'll be interested in something can even render my own custom colour faces in monochrome.

https://github.com/redguardtoo/rewind

Resume Emacs last completing-read session with saved input.

Inspired by ivy-resume in ivy.el but uses only native Emacs API and has no third party package dependency.

It's still in early stage. Please don't hesitate to report any bug.

UPDATE: I renamed the project to cmd-rewind, so the new url is https://github.com/redguardtoo/cmd-rewind

Hi all,

A few weeks ago, I announced Grove, the org-mode compatible Android app for note-taking and task management. Since then I've gotten a lot of good and helpful feedback, feature requests and bug reports. I truly appreciate the support from the community and the app continues to improve with each release. Thank you so much for using the app and being involved.

Grove has been renamed to Bloom. This was mainly done to avoid confusion with grove.el which was announced on Reddit a few months ago. With the new name comes new themes. Bloom Light and Bloom Dark are the official themes for the app. This is a rename, so you don't have to do anything on your end. Your settings, widgets, shortcuts, capture templates, all work as they did before.

I'm also excited to announce that the app is now available on F-Droid and Google Play. If you were part of the closed testing group on Google Play, I really appreciate you testing the app.

More features are coming and the best way to reach out about the app is via GitHub.

Here's the repo to star and follow: https://github.com/rrajath/bloom

F-Droid: https://f-droid.org/packages/com.rrajath.grove

Google Play: https://play.google.com/store/apps/details?id=com.rrajath.grove

GitHub Releases: https://github.com/rrajath/bloom/releases

Edit: I realized the Google Play link is not live yet because the latest version (remaining the app) is still in review. My production setup (adding countries/regions) was approved and I thought the app is live in production since both changes were submitted around the same time. Apparently the first submission takes a few days. The app should be live in a couple of days.

Is there a good way to keep logs on ongoing tasks like Interviews, bills ect? here is a madeup example of what I currently do but I dont love it.

* TODO Resolve billing issue

:PROPERTIES:

:CONTACT: ABC Insurance

:END:

:LOGBOOK:

- [2026-10-22 Thu 14:30] Phone call with Sarah Smith

- Discussed incorrect September charge.

- Sarah confirmed a $150 billing error.

- Promised refund within 5 business days.

- Reference number: ABC-12345.

- [2026-10-20 Tue 09:15] Email sent

- Requested explanation of September charges.

- Attached billing statement.

Hi Sarah, I noticed the bill was.......

:END:

** WAITING Confirm $150 refund

SCHEDULED: <2026-10-29 Thu>

Had the recent issue of company-box using the global help buffer for documentation previews whenever I have something highlighted in the autocompletions, and it changes what I was looking at as I type. This little snippet I wrote alleviates that and gives company-box its own dedicated help buffer to modify and display:

``` (defun my/company-box-doc-show-shim (orig-fun &rest args) "USE YOUR OWN HELP BUFFER!!!!!! STOP USING MINE!!!" (cl-letf* (((symbol-function 'help-buffer) (lambda () (get-buffer-create "company-box-help")))) (apply orig-fun args)))

(advice-add 'company-box-doc--show :around #'my/company-box-doc-show-shim) ```

Literally all it does is wrap the child-frame "show" function and forces `help-buffer' to return a different buffer. I love emacs btw

just to be clear, old guy here with little to no programming experience.

Every time i C-x C-f i get a warning that "Vertigo has detected an error" press C-h e to trace. I get the impression that vertigo is conflicting with some other display or selection process. Usually i can work my way to get what i need, but sometimes it throws me to a selection box that is disconnected from the initial process.

hope that is clear enough. I would like to just open a file, buffer, or whatever without seeing an error message.

I like trying out a lot of different fonts in emacs. This package makes that easy to do. It's lightweight and simple, and just picks and applies fonts. Whereas fontaine lets you pick presets, flick lets you audition fonts quickly.

More info and download here: https://gitlab.com/vegasharmon/flick