HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
joaotavora
eglot
Emacs Lisp2018–2026
joaotavora / eglot

eglot

A client for Language Server Protocol servers

Systems & InfrastructureLanguages & Compilers
Explore on GitHubRead Hacker News discussions
20Distinct people
22Mentions
1Explicit recommenders
2.6KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

A client for Language Server Protocol servers

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

The arrival of Language Server Protocol is going to make IDE-like functionality more evenly spread across traditional text editors, "modern" text editors and "IDEs". In Emacs I…

Myrmornis used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year22 dated mentions

Observed mentions: 2018-09-28 13:59:41 UTC to 2026-10-28 15:59:17 UTC.

02462018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments20182019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 7 mentions; 0 submissions, 7 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 5 mentions; 0 submissions, 5 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 0 mentions; 0 submissions, 0 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 1 mentions; 0 submissions, 1 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC202
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC000
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC707
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC202
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC303
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC505
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC202
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC000
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC101

What Hacker News says

22 sources
cyrialize·Oct 28, 2026
This is a good point, but I do want to mention that I feel like in the past 5 years we've had lots of extremely popular packages that hook into Emacs internals instead of rolling out their own architecture. For example, corfu [0] versus company [1]. Company works with capf, but you can also write your own backends for it (specific to company). Corfu also works with capf, but all backends are capf functions instead of a corfu specific backend. Another good example is eglot [2] versus lsp-mode [3]. Eglot is actually packaged with Emacs now. There's also other stuff, like vertico [4] (and others that are recommended to download) versus helm/ivy. I also want to mention that packages that hook into Emacs more don't necessarily mean that they're better. From my POV it's more like you get a lot more things for free and the documentation you dive
Read the rest
into will be Emacs specific instead of package specific. It all comes down to preference. Vertico/Counsel/Orderless is very nice, but Helm and Ivy are fully featured (I always forget how much Helm has for you). I use corfu, eglot, and vertico now. I have thought about going back to helm and company, especially since I was very familiar with company's backends for a long time. [0]: https://github.com/minad/corfu [1]: https://github.com/company-mode/company-mode [2]: https://github.com/joaotavora/eglot [3]: https://github.com/emacs-lsp/lsp-mode [4]: https://github.com/minad/vertico
In Emacs Turns 50
dustfinger·Mar 6, 2024
> My kids are all on Linux computers That is great to hear. My kids are both on pi 4s, but we customized the Debian distribution quite a bit to optimize its hardware acceleration capabilities and to overclock the hardware as much as possible. The pi boots from a fast nvme usb drive and i/o peripherals are connected via a fast usb hub. They are cooled by the ice tower [1]. They are both using exwm [2] and do not require a mouse. They both type on plank mechanical keyboards from olkb. All of this customization they found quite exciting. Especially being able to mess with their own keyboards. > I'm trying to wean them off iPads and consumption devices. But it feels like addictive apps can draw them back very quickly (looking at you, YouTube). We do not own any ipads. Only desktop computers, and I own a couple of laptops, such as the librem 1
Read the rest
4 and the mnt-reform. Youtube is a bit of a problem, I agree. They need access to it for their schooling at the moment, but the use of it does need to be limited, and the content limited as well, or they will just start watching brain numbing junk. I have decided not to block anything on our network with the goal of establishing a sense of trust, but I also don't allow them to have free rein. It is an endless exercise in finding the right balance :-). To be honest, it is much more of a problem with my son, then it is with my daughter, who spends a lot of her free time drawing and writing and isn't as entertained by youtube videos. As for teaching them to code, I have been giving them series of exercises and challenges that build up their skill with a few goals: 1. to build their own online mud (multi user dungeon) 2. to write their own compiler 3. to write their own operating system 4. to make their own computer 5. They each have come up with their own personal projects, so I tailor exercises to help them with problems that they need to solve For our development environment, we use emacs + eglot [3], which is not surprising since the windows manager is exwm. I make them compile and debug from the command-line, because I want them to be competent with standard command-line tools. Fancy GUI-centric IDEs are distracting because all of the options are visible to them even though they lack the skill or need for such features. I wanted this to be a happy experience, so I have never pushed them, but always challenge them to push themselves. I spend a few hours with them every weekend, then a couple of hours with them mid week to help them with challenges. But that is not how I started. I started with 1 hour first thing every morning Monday to Friday to teach them the basics and get them inspired. If they seemed drained, or I sensed that they needed a break, I just let them have a day off. We also play erion mud [3] and sometimes hexonyx [4] because I wanted them to understand what a mud is all about and to build up interest. I am really into text-based games, so not surprisingly we play nethack (rogue like) [5]. I am also into interactive fiction and started them off on Adventure [6]. If you are interested in interactive fiction, then you might enjoy reading "Twisty Little Passages - an approach to interactive fiction" by Nick Montfort [7]. Full disclosure, I believe that the main reason I am able to pull this all off is that my wife and I home-school our children. It is a challenge though. Very few families where we are from are similar to us in our philosophy of technology and education. [1] https://www.amazon.com/GeeekPi-Raspberry-Cooling-Cooler-Heat... [2] https://github.com/emacs-exwm/exwm [3] https://github.com/joaotavora/eglot [4] https://www.erionmud.com/ [5] https://mud.hexonyx.com/ [6] https://www.nethack.org/ [7] https://quuxplusone.github.io/Advent/play.html [8] https://www.amazon.com/Twisty-Little-Passages-Approach-Inter...
In Sugar: An activity-focused, open-source software learning platform for children
craftkiller·Oct 12, 2023
There are actually two separate issues in the thread: 1. The issue you identified which is about caching. It seems you can work around this issue by using a cache busting hook from cape. 2. An unsolved issue where eglot and LSP get out of sync which seems strongly correlated with using corfu. I've been experiencing this a lot with eglot+corfu+rust-analyzer. I'd estimate about once per hour I'll notice that things are just wrong, as in red underlines in nonsense places with nonsense error messages and completion no longer working or working incorrectly. Running a M-x eglot-reconnect "solves" the issue for another ~1 hour. The way these two issues were related is the author of eglot states that they have sunk considerable time investigating issue #2 with no success, and they argue that it is not worth their limited time to continue investig
Read the rest
ating #2 when corfu is broken by design[^] w.r.t. #1. And yes, I'd agree that this doesn't seem to be an LSP issue but rather an issue solely on the client side. [^] https://github.com/joaotavora/eglot/discussions/1127#discuss...
In How LSP could have been better
raincole·Oct 12, 2023
Recently I stumbled upon this issue: https://github.com/joaotavora/eglot/discussions/1127 I don't know enough about emacs and LSP to see the full picture, but it seems that both eglot's and corfu's maintainers, assumably very competent programmers, can't find a solution for this. I only skimmed the thread. My understanding is that LSP dumps a long list of completion candidates at once and they can't decide a cache strategy that works well with existing code...? If someone who know more about this please enlighten us.
In How LSP could have been better
vsundar·Sep 9, 2023
With lsp you don't need tags. You essentially have a lsp server like clangd [0] running in the background for finding references, definitions, code completion etc. With the latest release 29.1, emacs comes with an in-built lsp client - eglot[1]. So you need to (a) Set up clangd or some other lsp server for c++. Make sure it's accessible from emacs (use something like exec-path-from-shell to get your shell paths into emacs) (b) Set up your project for clangd - this involves generating a compile_commands.json which basically lists the full compilation invocation of each and every file in your project. CMake has options to do that and likely many other build tools or maybe use something like bear[2]. (c) Enable eglot (install the package if needed on older versions of emacs) and configure appropriately. I also use projectile for project mgm
Read the rest
t though emacs now has something in built for that too. I can post my configs if that helps. [0] https://clangd.llvm.org/ [1] https://github.com/joaotavora/eglot [2] https://github.com/rizsotto/Bear
In How to Learn Emacs (2012)
oehtXRwMkIs·Oct 23, 2022
At least for web development I believe eglot is strictly worse. It does not support running multiple servers (e.g. tsserver and eslint-ls) (https://github.com/joaotavora/eglot/issues/976) which is supported by lsp-mode and neovim's built-in lsp client. Also, it does not have any equivalent to dap-mode which is lsp-mode only. Although worth noting dap-mode is currently useless for js (https://github.com/emacs-lsp/dap-mode/issues/369).
In Eglot has landed on master: Emacs now has a built-in LSP client
chlorion·May 31, 2022
>Finally for LSP, I always recommend Eglot over LSP Mode, as Eglot is written by an Emacs contributor that has deep knowledge of Emacs and Emacs Lisp. LSP Mode is written by volunteers on Github, and the code is nowhere near as good. This isn't really true at all, but even if it was, lsp-mode has a larger scope and has many more features than eglot. It's also much more actively maintained/developed than eglot is. Anyways, most FOSS code is written by volunteers. I really don't think that's a great argument against a FOSS project. Also see: https://github.com/emacs-lsp/lsp-mode/graphs/contributors https://github.com/emacs-lsp/lsp-mode/pulse/monthly https://github.com/joaotavora/eglot/pulse/monthly
In A vision of a multi-threaded Emacs
jonpalmisc·Apr 6, 2022
I use it at my current job in which I work in a large C++ codebase. I formerly used CLion. Whether Emacs is an IDE or not depends how you define IDE. I use Eglot [0] for LSP integration; this gives me IDE-like features like "jump-to-definition", syntax error highlights, warnings, etc. and integrates with company-mode [1] for code completion. This handles most of my needs for writing code. As for other things like a file tree, I've found that the built in `project-find-file` command combined with `vertico` [2] and `orderless` [3] makes finding files and navigating around projects easier; that pair behaves similarly to CMD+P in Sublime Text or VS Code. There are file tree packages out there, but I've found that I don't really need a file tree in practice and that I prefer navigating around projects with fuzzy file search and grep. [0] https
Read the rest
://github.com/joaotavora/eglot [1] https://github.com/company-mode/company-mode [2] https://github.com/minad/vertico [3] https://github.com/oantolin/orderless
In What’s new in Emacs 28.1?
zxv·Feb 4, 2021
The emacs support is great. I use emacs 'racer' and 'lsp' packages full time for development. There are two popular emacs packages for rust-analyzer: lsp[0] and eglot[1]. lsp (language server protocol) package is the default for racer. Eglot has far more features and is correspondingly resource hungry. Detailed type information has a super helpful impact on my ability to review Rust code in general. I find reviewing rust code much more productive when I can see what owns a variable, how long it lives, and how it's being used (immutable vs mutable). So yea, lsp or eglot. Super helpful. [0] https://emacs-lsp.github.io/lsp-mode/ [1] https://github.com/joaotavora/eglot
In Rust-Analyzer Architecture
bananadrama·Nov 10, 2020
After 10+ years of Eclipse, Vim, Atom, and IntelliJ... I've bet on Emacs over the past few years on the basis of https://en.wikipedia.org/wiki/Lindy_effect and that it holds a unique space in computing re programmability: https://martinfowler.com/bliki/InternalReprogrammability.htm... The authors mention "With code completion, Git control, and even automatic deployment systems, modern IDEs are a Swiss Army Knife of features.", perhaps without realising that: * code completion has been standardised via LSP (e.g. https://github.com/joaotavora/eglot works great, and is planned to move into upstream Emacs ) * Emacs has great Git clients (Magit, vc-git) Diversity of tooling shows we're experimenting. Good!
In Why are so many coders still using Vim and Emacs?

Showing the 15 most recent of 22 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.