r/emacs

This is NOT my post.

I'm sharing it with the author's (thanosapollo) permission, though.

For those who aren't familiar with his work, he's the author of bibliotheca, emacs-forgejo, gnosis, jabber.el, and yeetube, as well as many other contributions to Emacs.

I hope you find this post as fun and educational to read as I did.

Eat had been working great for me for the past year. Now, since I have some spare time, I'm thinking of doing some work on Eat. So, wanted to do a quick survey to decide what to pick.

1. How are you all using Eat?
2. What feature do you think should be added? What hooks should be added?
3. How are you configuring Eat in your init.el? Are there any non-trivial customizations that might benefit everyone if they had been part of Eat?
4. What advices are you applying on Eat, that in an ideal world, shouldn't have been needed to be implemented as advices? Like, what type of dirty hacks / monkey patching are you doing? Maybe we can add more user options and/or hooks.
5. Do any of one actually depend on the "single elisp file" nature of Eat? I was thinking of splitting it up into 3 or more files; 8000 lines is no joke.
6. General commentary on Eat.
7. Any wild idea (like, maybe an eat-comint-mode, or a new keybinding mode, or even running a terminal in an Org buffer), feel free to say whatever comes to mind.

Would appreciate the community's opinion. However of course, don't expect anything yet, I had been pretty bad at keeping words. :V

A week or so ago I wrote about how I implemented my new blog in Emacs Lisp: https://martinsos.com/posts/my-blog-in-elisp. At that time I linked from it to the public "snapshot" of the source code of my blog at the moment of writing the article.

Since then, however, I turned that snapshot into a proper starter template for creating your own blog in Emacs Lisp: https://github.com/Martinsos/blog-in-emacs-lisp .

I derived it from how I implemented my blog, but removed all but a few example pieces of content, depersonalized relevant parts, and made sure it is in the right state to serve as a starting point for anybody who wants to use it for their own blog. Start should be as easy as cloning the repo and running make && make serve.

I also keep updating it as I add new features to my blog. My blog is close to being feature complete though and I want to keep it minimal so I don't think there is much to keep adding, but if I do, I will keep propagating the changes. I would also love to do it in the other direction, if somebody has any ideas how to improve the template (I am an experienced engineer but intermediate in elisp), I would love to propagate those back to my blog.

I hope you find this useful, that this possibly encourages you to move your blog to Emacs Lisp, and as always, I would love to get any feedback, particularly on the code architecture / decisions!

p.s. I feel a bit silly adding the following disclaimer, but in the times we are, I know I would appreciate it as a reader:

On AI usage: This project is not vibe coded or AI driven. I do use AI as one of the tools in my repertoire, but all the code in this project was written by me, every detail/polish and every decision was made by me, with understanding and care. I highly care about the quality of my work and love writing clean code and tweaking all the little details. This is my side project and I was in no hurry so I gave myself time, enjoyed the learnings and had a lot of fun with it.

I was wondering if I could have all of the features of obsidian that an emacs user would want minus the subpar gui editor?

Was wondering if anyone else has done this? like a _headless_ obsidian vault with encryption etc and emacs as my editor. Then obsidian apk for android.

This is my sideshow in Sacha Chua's May Emacs Carnival. Enjoy!

Sean has created the emacs-31 a few minutes ago:

• https://cgit.git.savannah.gnu.org/cgit/emacs.git/log/?h=emacs-31
• https://github.com/emacs-mirror/emacs/commit/311f1fe2ba2a4d069715c992ba839645b55a9427
• https://github.com/emacs-mirror/emacs/tree/emacs-31

I have to learn emacs lisp for my program language and design course but Ive been ive known somewhat about it for a while. Ive browsed this subreddit and keep seeing people ranting and raving about how customizable it is and how you can tailor it to exaxrly what your workflow needs but could some one give me examples of the usefulness of this extreme level of customization? Like is it about automation of tasks or maybe faster text editing like vim? I kinda sort understand that its a whole environment that can do a lot of different stuff but i guess i just dont understand why its so great. Im assuming it was absolutely wild back when all you had was a terminal but If I can optimiz my workflow with it now then Id like to try it out.

TLDR what are some of the ways you customized ur emacs config and why? what does it actually improve in your daily life/workflow

Does anyone know how to set the Caps Lock key as the Hyper key so that Emacs reads it as the hyper modifier (H-) under Gnome Wayland?

I've tried using Gnome Tweaks but it doesn't work. I then went down the rabbit hole with Gemini, and it kept suggesting me to create an xkb config to modify Caps Lock behavior, but none of it was ever registered as H- by Emacs.

Any ideas?

Is there a way to make Emacs prefer showing buffers with the same major mode when I kill a buffer instead of random buffers (or whatever order it uses)?

I just bricked my session (loaded "package.el" from the next version of Emacs), and I wanted to kill all Agent-Shell sessions one by one, and write a prompt to save what it has in the context into SESSION.md file.

And after a few kills (I have about 10 agent-shell buffers that I toggle in one window), it changed to something totally random (a yaml file).

I want to have all major modes one by one when I'm killing buffers.

I asked Grok, but the code didn't look very nice. There should be some clean way to do this.

What is the best way to add this to Emacs?

It would be nice if you could just sort (group by) the history kill buffer is using, by major mode.

Just wanted to share this here. At some point, I realized that typing too fast in a buffer managed by Eglot was leading to stuttering, even small freezes when e.g. repeatedly adding new lines. The profiler led me to eglot--post-self-insert-hook and jsonrpc-request, the former referencing :documentOnTypeFormattingProvider. This 'capability', which implements automatic formatting while the user is typing (something that may not be needed for most workflows), appears to force the JSON parser to chew way too much/often JSON.

Going for

(add-to-list 'eglot-ignored-server-capabilities ':documentOnTypeFormattingProvider)

makes Eglot simply ignore this capability, and it greatly smoothed out the flow. If you experience sluggishness when you're simply typing without even calling autocompletion, this could help.

Do you have other examples of LSP server capabilities that were leading to sluggishness?

Edit: I am on Emacs 30.2 (built from source) on Linux, with Eglot 1.23

Hey everyone, I’m new to Emacs and Elisp in general. I’ve gone through the documentation to grasp enough basic knowledge of Elisp for setting up my init file. I went with a modularized approach where I load packages from three different folders under the modules directory. Are there any caveats to this setup, or is it fine?

init.el:

   ;; Loading Modules

   (defvar module-list '("modules/config")   "List of module")
   (mapc (lambda (path)
   (add-to-list 'load-path (format "%s%s" user-emacs-directory path))) module-list)

   (load "options")
   (load "elpaca")
   (load "setup-package-archive")

   ;;Load core package
   (setq core-packages (directory-files-recursively (concat user-emacs-directory "modules/core-packages") "\\.el$"))
   (mapc (lambda (x) (load-file (format "%s" x))) core-packages)
   ;;Load external packages
   (setq external-packages (directory-files-recursively (concat user-emacs-directory "modules/external-packages") "\\.el$"))
   (mapc (lambda (x) (load-file (format "%s" x))) external-packages)

Modules directory:

.
├── config
│   ├── elpaca.el (setup elpaca)
│   ├── options.el 
│   └── setup-package.el (source package archives (e.g. Melpa))
├── core-packages
│   ├── dired.el
│   ├── eldoc.el
│   ├── emacs.el
│   ├── erc.el
│   ├── flymake.el
│   ├── isearch.el
│   ├── org-mode.el
│   ├── smerge.el
│   ├── vc.el
│   ├── which-key.el
│   └── window.el
└── external-packages
    ├── add-node-modules-path.el
    ├── corfu.el
    ├── ...

Just wrote https://github.com/jojojames/fzf-async as a companion package to https://github.com/jojojames/fussy as an alternative to consult/counsel. Works on my machineTM . Feel free to send bugs or questions.

I'm posting this in case anyone here is not subscribed to the emacs-devel mailing list.

>![SPOILER]: What's coming in emacs 31: https://github.com/emacs-mirror/emacs/blob/master/etc/NEWS!<

what shell, setup, stack do you use? I am having a tough time https://www.reddit.com/r/emacs/comments/1pskdxt/passing_code_not_data_to_agentshell/ & even figuring out a proper terminal use workflow.

furthermore, i imagine having an inbuilt agent in emacs would have ux superpowers that current tui and web-chat-based ui doesn't, by having it dynamically control my ui pertaining to the intent/task we are doing.