One of the first and most often requested features for Ghostel was proper tmux support like iTerm2 has. There were again a lot of changes in Ghostel over the last month, and one of them is a proper public API that you can use to write your own multiplexer package on top of it. This means that you can now make a terminal that has no process. Check the readme for more info on how to integrate.
With that in place, there are two new packages making use of it: ghostel-tmux, an iTerm2-style tmux integration, and rexel, which uses Rex, the new multiplexer from superlogical, as a backend. Rex currently only has a macOS app, so with rexel you have a full-featured client for the Rex server on Linux/FreeBSD/Windows.
ghostel-tmux and rexel are still very new, so I'm happy to hear any feedback.
On the Ghostel side, u/baokaola completely rewrote the Kitty graphics support. The old version was fine for simple cases but dropped transparency and stretched some images. The new one does transparency, overlapping images and cropping and images survive in the scrollback. yazi, timg, kitten icat and friends should just work, and Claude Code now shows images without the need to set an extra environment variable.
Then there were a few smaller additions:
ghostel-shell-command: like async-shell-command but with a real TTY. With `ghostel-shell-command-global-mode` that also covers dired and project.
ghostel ssh HOST: shell integration and terminfo on the remote without touching its rc files.
A mode line indicator and ghostel-status-next to jump to the terminal that is waiting for you, e.g. a coding agent asking for permission.
libghostty-vt 1.0: faster parsing and up to 30% more scrollback in the same memory.
file:// links open at the line (#L23), and lots of line mode and evil-ghostel fixes.
As always, feedback of any kind is very welcome :)
You can write a web app in Emacs Lisp, and Emacs runs it in the browser.
1. Subprocesses in the tab
Last time I wrote that the browser does not have normal POSIX processes, so Emacs features that depend on external commands do not work. Someone asked "Can it do M-x compile?" and I answered that shell/process access is the big missing piece.
Now it works. wasmacs has a small kernel inside the tab, and it runs real programs as processes (pipes, signals, fork, exec):
BusyBox ash and about 150 commands
git 2.52, GNU grep 3.12, GNU diffutils
CPython 3.14
Everything runs inside the page, not on a host machine. So M-x compile, M-x shell, eshell, M-x term, M-x grep, vc-git, Ediff and run-python work in the browser. Magit also works if you install it with package.el. SQLite is linked too.
M-x compile inside the browser tab. GNU grep and CPython run as subprocesses, and the compilation buffer links to matches.M-x shell inside the browser tab, showing a Git commit, GNU grep, CPython, and a pipeline. The mode line on the right shows vc-git.
2. Web apps written in Emacs Lisp
Some people joked that Emacs will become an Electron app. I went the opposite direction: the web app is written in Emacs Lisp 😄
The demo is Parens, a YouTube-like video browser. It has:
a home grid, and a watch page with the embedded player
search, channel pages, history, "watch later"
settings, English and Japanese
It is about 2,400 lines of Emacs Lisp, plus about 180 lines of JavaScript glue (YouTube player, clipboard, global keys).
Parens home. GNU Emacs running in the tab renders the video grid from elisp-react components.The Parens watch page with an embedded YouTube player, the Up next list, and Watch later.
It is made of four parts, all Lisp:
wasmacs: The real Emacs runs in the page. A page can send Lisp and get JSON back.
elisp-react: React (like the 2013 version) in Emacs Lisp. It has the following:
components with props and state, and a jsx macro
a keyed reconciler, effects, context, async/await
JavaScript only applies the DOM operations that Lisp computed. No build step, no Node. You just list your .el files in <script type="text/emacs-lisp"> tags.
elisp-studio: Emacs and your app side by side in one tab.
C-x C-s reloads the changed code into the running app, and the state is kept.
Flymake shows byte compiler warnings while you type.
You can also edit with your own Emacs, and the page follows your saves.
elisp-next: A Next.js-like layer.
A file in pages/ is a URL, and a file in api/ is a server route.
shared/ has types that both the page and the server check.
elisp-studio live reload. The title, code, and stylesheet change while the stopwatch keeps running.
pages/index.el /
pages/watch.el /watch?v=ID
pages/channel/[id].el /channel/ID
api/later.el GET and POST /api/later
shared/parens-types.el types that the page and the server both check
The server can also be Emacs. In the Parens "server mode", a native Emacs serves the page and reads the RSS feeds of the channels (a page cannot read them because of CORS). Both sides exchange printed Lisp data, not JSON, and load the same type definitions.
Parens server mode, served from Docker by GNU Emacs 29.3. Four Emacs workers run behind Caddy.
Deploy
Without server.el: It is a static site. GitHub Pages or any web server is OK. Parens is on GitHub Pages.
With server.el: You only need bash and GNU Emacs 29 or later. Any Linux machine with Emacs, or Docker. No Node, no npm, no build on the server.
run.sh: The studio downloads your project with run.sh. Run ./run.sh, and Emacs becomes the web server.
Proxy and systemd: Caddy and nginx configs and a systemd unit are included. WORKERS=4 ./run.sh runs 4 Emacs processes for 4 cores.
Docker: Dockerfile and docker-compose.yml are included.
I tested it with Docker before this post. The setup was Ubuntu 24.04 with its own Emacs 29.3, Caddy in front, and 4 workers. Two apps worked from Chrome:
the studio's template app
Parens server mode: the feeds and "watch later" work, and the data is kept after restart
The screenshot above is Parens from that container. Also the CI runs this Docker test (HTTP and HTTPS) for every push.
Last time I wrote "We need the real Elisp engine." This is what the real Elisp engine can do in the browser.
A bug I liked
I wrote Parens to find what is missing for a real app. I found 57 gaps, and all of them are closed now. My favorite one: in the page's Emacs, no hook was running at all. Here is why:
The page starts Emacs in batch mode, and batch startup runs until kill-emacs.
This ends main(), but the WebAssembly runtime is still alive.
On the way out, shut_down_emacs sets the C variable Vrun_hooks to nil.
After that, every run-hooks returned immediately and silently. Also the hooks called from C.
The fix sets Vrun_hooks back when a request comes.
Limits
It is still a hack. Please do not build your business on it.
Download: An app downloads about 5 MB on the first visit. The studio's editor Emacs is about 150 MB (then cached).
Memory: Each tab reserves 1 GiB memory for Emacs. Parens used 265–335 MB in desktop Chrome.
Browser: I tested only on desktop Chrome, not on a real phone.
Deploy: I load-tested with Caddy and nginx on Mac, and tested it in Docker. Not yet on a real server with HTTPS, and not with the systemd unit.
Network: No raw sockets, so Emacs in the browser cannot listen on a port. package.el and git over network need a small Chrome extension (companion).
No server-side rendering, no code splitting.
Links
My code is MIT. Emacs and the bundled programs keep their own licenses, and the sources are published.
I made this hack to give Emacs users something fun to play with again. Emacs users, please give it a try. I want to hear what you want to build with Emacs Lisp in the browser, and what is missing.
I'm wondering if anyone has a recommendation for what packages to use to define project templates, to speed up the setting up of the file structure of new projects. Like yasnippet, but for multiple files.
Is there anything like this in a doom module? I've seen skeletor and ptemplate but neither seems to have any activity in at least 5 years (which isn't always bad for emacs packages).
Bonus points if I can use org-mode to specify the entire project structure in one file.
A while ago I found this post about Emacs In the Age Of Magic (https://commandlinesystems.com/magic.txt) in HN. The author was arguing that coding agents have eroded the advantages Emacs users have relied on for decades. It made me think, and I ended up writing a longer reply on my blog. I thought it would be worth sharing my personal take here too, and maybe getting a discussion going.
I read the situation differently. If an agent can rewrite any program that resists customization, the software that already bends to anything is in a good position. Agents lower the cost of learning Emacs, and I think its value stays where it was. Emacs also happens to be a comfortable place for an agent to work: it's text all the way down, it documents itself live, and `emacsclient --eval` lets the agent talk to the running session directly.
Most of the post is about how this looks in practice for me:
- my literate `config.org`, now co-written with an agent under an `AGENTS.md` rules file, including an F7 cheatsheet generated from the live keymaps, so it stays in sync with the actual bindings
- an Org-mode Eisenhower matrix I first wrote about in 2019, rebuilt as a read-only view you can act from, chosen through an ADR and a Pugh matrix
- blueprint.el, an architecture-documentation package designed to be driven by agents, which grew from a Python prototype into ~9,600 lines of Elisp
- the essay's point about no longer knowing how your own software works, which I take seriously, and how I try to deal with it: reading prose, diffs and tests, and keeping everything documented in Org
There's one thing in the essay I fully agree with: a computer that does whatever you can imagine is a form of freedom. Emacs has been offering that since 1976. What's changed is how much it costs to take advantage of it.
Part of my job is walking into systems nobody remembers anymore and writing down what they are: which components, how they talk, what they do for the business, where they run, what could go wrong. The documents run to a few hundred pages, several people write them at once, and the hard part was never the writing. It was knowing what to write, keeping the whole thing in shape, and being honest about what we hadn't verified yet.
Over the years that became a method, and the method became blueprint.el. It started as a Python script that generated Org files. One day I noticed I was leaving Emacs to run a program that opened, edited and rewrote Org files, which is the one thing Org has done well for twenty years, so I rewrote it in Elisp, on org-element and Org's own exporter, with Transient for the menu. Now the whole document lives where the rest of my work already lives: a master file, one directory per component, plain text in git, open points written in the text and counted, a dashboard in the spirit of Magit.
I'm proud of it, and since it lives inside Emacs I thought some of you might find it interesting. The templates are still in Italian (English is planned) and it isn't on MELPA yet. There's a half-documented demo project in the repository if you want to look around without starting from scratch.
Thanks to your outstanding and truly kind feedback, we’re really motivated to keep working. We weren’t lying when we said we had lots of ideas in our first post announcing the package.
Starting today, we’re adding a few new families that we’ve spent over a month working on. We hope you’ll like them just as much as the previous ones :)
The buffer switching after killing was improved just yesterday, and a gear that adds direct support for devenv was implemented (if you still use direnv for loading devenv, support for direnv is still there in Backpack).
Tempel was added for templating, and its gear has the configuration that enables candidate templates from completion at point (this could get some improvements, tho)
Windows support is there; imitating (or rather, copying) what Doom Emacs does, GNU Emacs will work best on Unix-like OS, tho.
Users can overwrite defaults of gears in backpack.d/init.el, previously any overwrite there would be overwritten by Backpack loading its gears, which was a confusing behavior. If you want additional leaf blocks in your personal configuration, you have to put them on backpack.d/packages.el.
A gear for debugging (as in "support for debugging adapter protocol") was added, and support for other programming languages as well, and much more!
Please give it a try and let me know what you think!
I am in my final year of studying computer science. When I switched to Linux, my first introduction to Unix text editors was Nano. This made me curious about other text editors, and I eventually learned about Vim and Emacs. I read about the editor wars and everything.
This intimidated me. I tried to stick with Nano for a while, but I started noticing its limitations, and I knew I should spend some time learning something more powerful.
My first choice was Vim. In online communities, Vim seems to be way more popular. And I liked it! For the first time, I realized how much more productive I could be compared to mouse based workflows. My whole experience with Vim even made me switch to tiling window managers instead of traditional desktop environments.
I fell in love with vanilla Vim. My configuration was pretty minimal, with just a few small enhancements. This was when I started exploring Neovim. When I tried it, it felt clunky and sluggish. I didn’t like it much because it seemed too opinionated. I prefer building my own configurations and installing plugins from the ground up. Neovim just wasn’t a good fit for my preferences.
I continued improving my Vim setup, but it still felt too basic, and in some situations, it didn’t quite suit my needs.
I knew about Emacs, but I quickly dismissed it because I had fallen for the anti-Emacs propaganda. I also noticed that many people were using Emacs distributions like Doom Emacs and others.
Recently, I’m not exactly sure what inspired me to overcome my ignorance, but I finally decided to give Emacs a try.
The only thing I can say is: I love it!
I quickly put together my own simple configuration. Within just a few minutes, I even managed to set up my email!
Now I want to do everything in Emacs! Studying for a math exam? I open my review PDF in Emacs! I’m also starting to learn Org mode so I can take better notes.
It’s like magic!
I still like Vim, but Emacs suits my needs much better. What I love most is how easily you can build a powerful, personalized setup from the ground up without having to rely on a preconfigured distribution.
I guess I’ve finally understood what all the Emacs enthusiasts were talking about!
May St. IGNUcius forgive me! 🙏
Edit:
I tried Lazyvim and not Neovim! Sorry for the mistake!
Just released v3.0.0 of java-agent-loader (JAL), a small Emacs package that automates the detection and setup of Java agents (like Lombok, JaCoCo, etc.) in your Maven or Gradle projects. The alternative is wiring them up manually, which gets painful fast when you switch between multiple Java projects using different versions of these libraries—especially in larger codebases and companies.
I noticed some folks prefer skipping lsp-java and eglot-java in favor of simpler setups using just vanilla lsp-mode or built-in eglot—so in v3.0.0, JAL now supports both directly out of the box (lsp-java and eglot-java are still supported).
If you're already using JAL, no config changes are needed—jal-lsp-java-mode and jal-eglot-java-mode keep their names and work as before.
Quick setup:
It'll be available on MELPA on the next sync, or you can grab it right away from GitHub using use-package:
Keep in mind that if you're not using lsp-java or eglot-java, you still need to have basic JDTLS support configured on your own—JAL isn't meant to replace them, just handle the agent flags. Check out other setup scenarios in the README.
Looking for testers and feedback!
Since this reworks how JAL hooks into LSP and Eglot clients, I’d really appreciate some input from you—especially if you're using vanilla eglot or lsp-mode, Gradle projects, or multi-module Maven setups. If you run into any quirks, broken setups, or have suggestions, drop a comment here or open an issue on GitHub. Thanks!
Original post for background. These two short videos demonstrate two simple productivity features of Hyperbole that you can learn in just a few minutes and then use productively every time you use Emacs. You absorb Hyperbole in parts, just like you do Emacs.
automatic copying and killing delimited regions when point is on a delimiter, without having to select the region. If you prefer the region highlighted, {C-c RET} (hui-select-region) does that.
{C-c RET} (hui-select-thing) selects bigger and bigger things with each press. If initially pressed on a delimiter, it selects the delimited region. If initially pressed on a program symbol word separator, it selects the entire symbol. If pressed at the end of a line, it selects the whole line.
Reddit indicated that tomorrow all rss feeds will shutdown. I’m sure that they’ll go through with it. I and, i assume, several other people in this group only visit Reddit due to RSS. I’ll probably stop checking after that.
Aaron Schwarz must be rolling his grave but I guess that’s the way it is.
I don't have too many buffers open, so I find C-x <left> and C-x <right> to be very convenient to switch to one of the other buffers.
The problem is scratch, Messages, eglot log, compile log, etc. which I don't want to appear in the list of candidates to cycle through. If I set switch-to-prev-buffer-skip-regexp to \\* then that does the job, but then now shell-mode, term-mode, etc. does not appear in the list either, which I want.
Alternatively, I can write a lambda function for switch-to-prev-buffer-skip to enable additional buffer types, but this is like a cat-and-mouse approach where I have to keep allowing more and more buffers.
I'm wondering if there's a better way and how other people are configuring this.
Original post for background. More videos than you can probably handle! A wealth of knowledge about Hyperbole's implicit buttons that save you time throughout many, many Emacs contexts every time you press the M-RET Action Key.
Org users can cycle their Todos through their states with one key, execute code blocks, toggle image display or pull up customized agendas. Hyperbole makes it easy to go from concept to no friction, easy-to-read buttons with custom actions.
Please ask any questions you have or comment on the videos here. If there are no questions, we'll assume everything is clear and everyone has mastered the material 😄
A long, slow demonstration of all of the built-in Hyperbole implicit button types in priority order (first matched context determines the action taken).
Knessy is a (yet another) Kubernetes-management package, with focus on discoverability and being able to juggle multiple contexts. It is heavily inspired by k9s by derailed and kubel by abrochard. Another source of inspiration is kubectl-tree by ahmetb.
I have built it for myself and my specific needs. I believe you could benefit from it the most if:
you manage a lot of large (100K+ CPU cores) Kubernetes clusters at once;
you debug, troubleshoot and investigate Kubernetes-related stuff on daily basis;
you experiment with your Kubernetes setup a lot.
If your Kubernetes operations boil down to occasional surgical intervention, this package is most likely an overkill.
I've been using it for months on daily basis and it helped me a lot; hope it helps you too!
TL;DR orpheus.el is a music player for Emacs. It provides a queue, tabs, a library, cover art, an equalizer, lyrics, and a visualizer, and it treats MPD, local files, and SSH as interchangeable backends. The SSH backend is the most distinctive part: it plays music stored on a remote machine without a daemon running there, without an NFS/SMB mount, and without a tunnel. For whole-disc FLAC images, it requests only the byte range for the selected track instead of transferring the entire image. The same player UI can drive MPD, local files, or SSH. The project is MIT-licensed, has no dependencies, and requires Emacs 29.1+.
Note: AI/LLM did a large share of the implementation work. I also wrote a substantial amount of the code myself, tested the player, wrote unit and integration tests, and set the technical implementation direction and standards. This was a long-standing wish of mine, and now it’s real.