Hello! I'm a long-time Vim/Neovim user, and I've wanted to try Emacs for a while. I finally decided to use it for a month to see whether it could become my daily driver and main editor.

Here are my dotfiles for anyone interested in seeing my configuration.

I tried to replicate my Neovim setup as closely as possible while still respecting the “Emacs way” of doing things. I used built-in features whenever possible and only installed packages when I felt they were truly necessary.

I tested Emacs for almost all of July 2026 using GNU Emacs 30.2. These are my thoughts so far.

Keybindings

I got used to the Emacs keybindings surprisingly quickly and experienced very little friction. When I'm in the terminal, I already tend to use shortcuts such as C-a, C-e, C-k, C-f, and C-b to move around.

I don't think the default Emacs keybindings are that bad. Most of them are actually quite good. I even find some of them faster than their Vim equivalents, and they are not too difficult to get accustomed to.

However, some keybindings are genuinely unpleasant. M-v, for example, feels awkward to me. In general, many of the Meta-based bindings are not particularly comfortable.

Code Navigation

This is one of my biggest issues with Emacs.

I dislike how dependent code navigation is on the package ecosystem and the quality of individual major modes. To navigate efficiently through code structures, you often need a well-written major mode.

In Vim, basic text operations work consistently regardless of whether you are using Java, C, PHP, or another language. You can operate around common structures such as parentheses, brackets, braces, and quotes without relying heavily on language-specific support.

These structures are common across many programming languages, so I would prefer Emacs to provide more consistent built-in ways to navigate and manipulate them.

For example:

(message "hello beautiful world")
;;               ^
;;               Cursor is inside the quoted string.

Pressing C-M-k here deletes only the next expression, which in this case is the next word:

(message "hello  world")
;;               "beautiful" was deleted.

To delete the entire string expression, the cursor must first be moved to the beginning of the string:

(message "hello beautiful world")
;;       ^

This feels unnecessarily precise compared with Vim's text objects, where the operation works as long as the cursor is somewhere inside the quotes.

Before someone suggests Evil Mode: I personally dislike the idea of using a Vim emulation layer. It is not really Vim, but it is also not really standard Emacs. To me, it feels like being stuck in an awkward middle ground rather than fully using either editor.

Built-In Features

Most of the built-in features are excellent. Some of my favorites are:

• Dired
• project.el
• completion-preview
• use-package
• Org Mode

However, some built-in features still feel incomplete.

Eglot

Eglot was straightforward to configure. I tested it with Intelephense, and it worked flawlessly.

However, I was disappointed to learn that using multiple language servers in the same buffer requires an LSP multiplexor.

That feels like a significant deviation from the behavior of many other editors, and it adds complexity that I don't particularly want to manage.

I am aware of lsp-mode, but it seems heavier than what I am looking for.

As it stands, Emacs has a solid built-in LSP client, but its limitations prevent me from comfortably using it as my daily driver.

Tree-sitter

The current Tree-sitter experience is not good.

I understand that it is still a relatively new feature and that many major modes do not support it properly yet. I have also seen that Emacs 31 is expected to improve the situation.

However, in Emacs 30.2, it does not feel particularly usable for my setup. It requires too much boilerplate, and I don't want to spend time maintaining that configuration.

I have high hopes that Tree-sitter will eventually improve the code-navigation issues I mentioned earlier by allowing structural navigation based directly on syntax-tree nodes.

Packages I Used

I would also like to mention the packages I used while configuring Emacs, in case anyone else is going through a similar journey.

Doom Themes

Doom Themes

There is not much to say here. I used the doom-gruvbox theme, and it looks great.

Reformatter

Reformatter

This is a lightweight and straightforward package for configuring code formatters.

I used it to set up:

• php-cs-fixer
• nixfmt
• xmlstarlet

It worked very well.

inhibit-mouse

inhibit-mouse

I wanted to force myself to use the keyboard, so I installed this package to disable mouse input.

It worked well, although I was surprised that Emacs does not appear to provide this as a simple built-in option.

direnv

emacs-direnv

I use Nix and direnv to manage my development environments and environment variables, so this package was essential for me.

It worked very well and integrated seamlessly with project.el.

Ghostel

Ghostel

This is a great package.

I almost gave up on finding a good terminal emulator embedded inside Emacs, but then I discovered Ghostel. It works extremely well and feels very fast.

It was probably the MVP of all the packages I tested.

Git Gutter and Magit

Git Gutter and Magit

Git Gutter is a great package for viewing and interacting with Git hunks directly inside a buffer.

Magit probably does not need an introduction. Almost everyone already knows about it, and it is excellent.

Final toughts

Overall, my time with Emacs was much more positive than I expected. I enjoyed many of its built-in features, and the general extensibility of the editor. However, code navigation, structural text editing, Tree-sitter support, and Eglot's limitations are still big issues for me. For now, I don't think Emacs will replace Neovim as my daily driver, but I will continue following its development.

A rundown of features added since last post https://xenodium.com/agent-shell-0-63-updates

I'd like to introduce JAL (Java Agent Loader), a package I developed for Java developers using Emacs. JAL extends lsp-java or eglot-java (both required dependencies) to automatically detect and configure Java agents in your projects, removing the need for manual setup. It supports both Maven and Gradle builds for seamless integration with common Java project structures. JAL works out of the box with popular Java agents like Lombok, JaCoCo, and OpenTelemetry. You can find JAL on GitHub and install it directly from Melpa. If you want to simplify and automate Java agent setup in Emacs, I encourage you to give JAL a try.

(use-package jal
  :custom
  (jal-auto-setup t)
  :config
  ;; Optional: override known agents or add new ones
  (jal-additional-agents
        '( ;; Override a known agent with custom parameters
          ("org.jacoco.agent" :params "destfile=target/jacoco.exec")

          ;; Add an agent not in the known list
          ("my-custom-agent" :jar-path "/opt/agents/my-agent.jar")
          ))
  (jal-lsp-java-mode 1)) ; or (jal-eglot-java-mode 1)

Where an exercise to automate copying over a GitHub issue into Org Agenda turns into a think-piece on malleable computing in Emacs.

I’d like to introduce trailing-newline-indicator, a simple yet effective Emacs package that brings visual clarity to a subtle but persistent editing issue: knowing whether a file actually ends with a trailing newline.

While many Emacs users rely on configurations like require-final-newline or automated save-hooks, these silent approaches have clear limitations. Configs can fail silently, leak across buffer types, or be bypassed in unformatted buffers like quick notes, scratch files, and third-party major modes.

Relying on built-in visual tools also falls short:

• The Emacs C-Engine Limitation: Due to how Emacs treats newlines as line terminators rather than line generators, native line numbers (display-line-numbers-mode) leave the trailing position completely unnumbered. As discussed in this thread, standard fringe indicators do not treat that space as a newline, and the maintainers have no plans to change this behavior.
• UI Noise: Options like indicate-empty-lines apply markers to every empty line past the end of the buffer, cluttering your window instead of targeting the actual point of ambiguity.

trailing-newline-indicator solves this cleanly and surgically. It places a single, subtle visual marker in the line-number margin or fringe only at the true end-of-buffer position. It performs a quick, instant check at the very end of the file rather than scanning the entire document, making it completely lightweight and imperceptible even in massive files. You get unambiguous feedback with zero UI clutter or performance penalty.

You can find the package on GitHub, and it’s also conveniently available through Melpa.

Hey everyone!

I’ve been using Emacs for programming for a few months now, but I originally picked it up with Org mode in mind. I’m starting my Computer Science degree next month, and I want to use Org mode for my class notes.

Since I’ve never actually taken notes before in my life, I'm effectively starting from scratch with both Org mode and structured note-taking.

What are your best tips for a simple, fast Org mode note-taking workflow?

Thanks in advance!

This has been a pet peeve of mine for a while. I use olivetti and visual line mode pretty much all the time in org buffers, and inevitably I'll get sections of quotes or source blocks that look the the first picture. It looks unprofessional. So, I made a package to address that. Hopefully someone here finds it useful!

Currently available on my gitlab.

Hi r/emacs,

I made a small completion-style package called flex-x. It extends Emacs's built-in flex style rather than replacing it with a new matching engine.

For me, orderless is still the gold standard among completion styles. In particular, I like how space-separated components make it easy to narrow a large candidate set, and how leaving sorting to the completion table or frontend often produces a very natural order—for example, preserving the useful order of find-file candidates. Its matching-style dispatch also makes integrations such as migemo and pyim possible.

At the same time, I also like one property of built-in flex: it scores matches, so candidates that are more closely related to the input can rise to the top. The downside is that loose flex matching can leave many candidates in the list, and those weaker matches can become noise.

flex-x is my attempt to combine the parts of those experiences that I find useful:

• space-separated AND filtering: every input term must match;
• history-aware sorting: minibuffer history first, then flex match quality;
• optional Corfu history sorting outside the minibuffer;
• customizable extra matchers or regexp expanders for non-ASCII candidates, including migemo and pyim;
• standard match highlighting, plus whole-candidate highlighting for strong literal or consecutive word-prefix matches.

That last point is meant to make a noisy flex result set easier to scan. A loose subsequence match keeps the normal per-character highlighting, while a stronger match—such as a contiguous term or a sequence of word prefixes—is emphasized as a whole.

The package is frontend-agnostic: it uses normal completion metadata and is intended to work with the completion UI you already use. It does not require Vertico, Corfu, migemo, or pyim. Optional non-ASCII matching is also bounded by default so that it does not perform an unlimited scan of very large completion tables.

Basic setup:

emacs-lisp (use-package flex-x :ensure t :config (setopt completion-styles '(flex-x basic)))

Migemo integration can be as small as:

emacs-lisp (with-eval-after-load 'migemo (setq flex-x-extra-pattern-function #'migemo-get-pattern))

For Chinese candidates, pyim can provide pinyin-based regexp expansion:

emacs-lisp (with-eval-after-load 'pyim (require 'pyim-cregexp-utils nil t) (setq flex-x-extra-pattern-function #'pyim-cregexp-build))

flex-x requires Emacs 30.1 or newer and is available from MELPA:

• GitHub: https://github.com/kn66/flex-x
• MELPA: https://melpa.org/#/flex-x

I would especially appreciate feedback on the matching and sorting behavior: whether history-first ranking feels natural, whether the stronger highlighting helps when flex produces many candidates, and whether the extra-matcher API works well for other non-ASCII search tools.

Directly show the effect

This package was previously for my personal use, and now I've separated it into its own repository and will try to publish it on MELPA.

Repository address:

https://github.com/zHaOdANiuu/material-icon.el

I decided to try Emacs 31.0.90 and it works nicely so far with one exception: I get an error for the casual Info installation (keymap-set Info-mode-map "C-o" #'casual-info-tmenu) stating that Info-mode-map is a void variable. It seems that the Info-mode-map is only loaded when running info for the first time. At least after I open Info the issue disappears. It does work on Emacs 30.2 so it may be some change in Emacs 31 even though I din't find anything in NEWS.

Anyone else seeing this or advice what I'm doing wrong or how to fix it?

Find the blog post here: https://jointhefreeworld.org/blog/articles/emacs/emacs-eglot-scala-kotlin/index.html

When Emacs 29 made eglot the built-in, default Language Server Protocol (LSP) client, many of us rejoiced.

It is lightweight, fast, adheres strictly to Emacs philosophy, and doesn’t try to reinvent the wheel.

However, being minimal means that when an LSP server steps out of line or acts quirky, eglot doesn’t provide a million customizable toggles to fix it out-of-the-box. Instead, it expects you to leverage the power of Emacs Lisp.

In this post, I will dissect my production-ready eglot setup (part of my heks-emacs configuration) which I use in my day-to-day work, with Scala and Kotlin (and some Java).

For reference, find my full Eglot config here: https://codeberg.org/jjba23/heks-emacs/src/branch/trunk/src/modules/eglot.el

For some reason reddit started to show me posts for r/markdown and there are a thousand posts about editors/readers/local markdown file set viewers. Half of the people are looking for tools, the others have some AI vibe coded slop thing they built.

All the while, I'm thinking first " But markdown doesn't need WYSIWYG editing, its perfectly readable as text." and then "markdown-mode does all of that really well". Now I just need to spend some time trying out the new markdown-ts-mode extensions.

I am working on a presentation for emacs, and I want to show some demo videos, preferably gifs. Recording the screen is tedious. For now I'm just using a custom keybinding to take screenshots of my emacs window and combining them to create a gif. I've found a few packages but they use tools that are X11 exclusive and I'm on wayland. If someone has a convenient package for this, it'd be really helpful!

A genuine limitation I've found with Emacs is that the header-line is restricted to one line. Something I wanted to implement was multilayered tabs, or stacked tabs in the header of a child frame, but Emacs just doesnt let you do this. Another package that hit this problem is topsy.el, the author mentioned how they can only show one context line rather than 2 or 3 because of this limitation.

I know there are workarounds for this, you can always find another way, but rendering stuff in the header in particular is very convenient.

Wrote a blog post on controlling a YouTube video playing in the browser from inside emacs (on Linux).

https://www.naiquev.in/controlling-a-youtube-video-from-emacs.html

It's a trivial setup and all I had to implement was glue code, but it comes in handy when I'm watching a YouTube video and taking notes at the same time in emacs using org-roam.

I don't think it'll be too interesting, but here's my little note.

https://github.com/larrasket/org-pad.el

Hi everyone,

I’ve been working on an app called Orgenda for a while now, and I think it’s at a point where I’d love to get some feedback and share it with the world.

The goal was to bring the Org Agenda experience to iPhone, iPad, and Apple Watch while making it feel native, fast, and easy to use. I wanted to minimize the number of taps needed to view, create and update tasks, so interacting with your agenda stays quick and effortless.

Orgenda is available on:
- iPhone
- iPad
- Apple Watch

Any feedback, bug reports, feature requests, or ideas are greatly appreciated. Thanks to everyone who takes the time to try it out!

TestFlight:
https://testflight.apple.com/join/JdsJyETQ

Pretty much every new dev tool is using Pierre's https://diffs.com JavaScript library for rendering code diffs and it comes with a couple really nice themes. I ported some of them to emacs here https://github.com/shaneikennedy/pierre-themes.el

Choose the option that best represents how you use Emacs most of the time. If you regularly use it for multiple purposes, please vote for the one you spend the most time on. Thanks for participating!

Completion, navigation, refactoring, live debugging — all running in a terminal over SSH. Recorded a walkthrough.

Config (MIT): https://github.com/jclosure/vscode-flavored-emacs-2026