Hacker News Reader

Comment by benreesman | Hacker News Reader

I’m really picky about my tools in general and latency in particular, and I give Zed a spin from time to time, it’s sweet. Clean, minimal design aesthetic, tree-sitter, tight code, it’s a nice bit of work and I dig it a lot.

But emacs 29 with the right flags and a tuned GC (no one does this! it’s got a heap-size from the 80s!) is just as snappy and has more amazing packages than VSCode.

There’s a market for people who want something snappier than VSCode but less labor-intensive to set up than emacs, and I wish them luck: I think it’s a front runner there. But I can’t imagine switching my main axe up with a holy shit moment a lot crazier than tree-sitter in 2024 and not having the render loop be in JS.

View on HN

People are asking what settings would be useful to tweak. Check out the following:

- gcmh -package and gcmh-mode and/or gc-cons-threshold variable (former should take over the latter)

- read-process-output-max

- jit-lock-defer-time

- package-native-compile

Doom Emacs sets gcmh in its initialization so tweaking that might not be needed there. You may still want to touch gcmh-high-cons-threshold and gcmh-idle-delay-factor. Here are mine currently:

    (setq gc-cons-threshold (* 1024 1024 1024))
    (setq gcmh-high-cons-threshold (* 1024 1024 1024))
    (setq gcmh-idle-delay-factor 20)
    (setq jit-lock-defer-time 0.05)
    (setq read-process-output-max (* 1024 1024))
    (setq package-native-compile t)

I've done nothing scientific to check out if these help at all, though, so take them with salt. With and without these, emacs seems quite sluggish at least on a Macbook, in certain modes. On Linux things seem to be a bit better.

The thing about gc-cons-threshold is that, too low a value and it will collect garbage too frequently. While a high value will drastically reduce frequency, but then GC pause will be big and you will likely feel whole system freeze and stutter when it happens. For me, 1GB is too high because I sorta notice the pause, I set it to 32MB but completely disable GC when minibuffer is active:

    (defun my-minibuffer-setup-hook ()
      (setq gc-cons-threshold most-positive-fixnum))

    (defun my-minibuffer-exit-hook ()
      (setq gc-cons-threshold (* 32 1024 1024)))

    (add-hook 'minibuffer-setup-hook #'my-minibuffer-setup-hook)
    (add-hook 'minibuffer-exit-hook #'my-minibuffer-exit-hook)

Eli Zaretskii (current Emacs maintainer) also thinks 1GB is too high, though for somewhat different reason:

https://old.reddit.com/r/emacs/comments/bg85qm/garbage_colle...

Here is an interesting optimisation that was merged in master, but didn't make the cut for 29 in time. I thought it improved snappiness:

https://tdodge.consulting/blog/living-the-emacs-garbage-coll...

---

Anyway, I also have these in my init (I nicked these from Doom which I don't use but they have done a lot of work to dive deep into these things, mostly around what improves start up but the following might help in general):

    ;; if you don't use RTL ever, this could improve perf
    (setq-default bidi-display-reordering 'left-to-right
                  bidi-paragraph-direction 'left-to-right
                  bidi-inhibit-bpa t)

    ;; improves terminal emulator (vterm/eat) throughput
    (setq read-process-output-max (* 2 1024 1024)
          process-adaptive-read-buffering nil)

    (setq fast-but-imprecise-scrolling t
          redisplay-skip-fontification-on-input t
          inhibit-compacting-font-caches t)

    (setq idle-update-delay 1.0)

I’m doing different heap sizes during package load, but I don’t have the mini buffer hook and in retrospect, I feel dumb.

If I do inline attribution you mind if I borrow that under MIT?

Go ahead. Though I don't think attribution is even necessary for something I myself may have borrowed from somewhere.

How do you get a reasonably fancy Emacs to start up/open files quickly? Every time I try to get into EMacs after adding a few packages it becomes painfully slow to open a file for editing. Then I try to understand Emacs server, then I fail / give up and go back to vim.

I've been using emacs as my main editor for years now and don't find the startup speed to be an issue - to the point I've never bothered with emacsclient:

It starts up with ~77 packages in half a second.

This is my config.

https://gitlab.com/ideasman42/dotfiles/-/tree/main/.config/e...

That’s pretty close to what I’ve been running on the GC tuning but I like parts of your spelling better.

This is going MIT as part of a bigger project in about a month (think Lucid s/C++/modern models/).

If I inline attribution you mind if I borrow this or that?

Use doomemacs for a start. It really optimizes startup time and offers vast included modules as well as great package management. https://github.com/doomemacs/doomemacs/blob/master/docs/gett... Oh and for Windows, WSL2 seems to be the fastest: https://github.com/doomemacs/doomemacs/blob/master/docs/gett...

Doom is a great start for a low-friction, extreme quality curated emacs setup. +1

Another +1 for using DOOM emacs.

So buggy for me.

Emacs server is quite straightforward. M-x server-start in a running emacs, then emacsclient <filename>. emacsclient -c if you want to open the file in a new window, or emacsclient -t if you want to open it in your current terminal. C-x # when you're done editing the file.

myhome>> emacs --daemon

  emacsclient -ca ''

Connect to the daemon if it’s running, start it if it’s not.

  alias emacs="emacsclient -ca ''"

Open it at 8am, close it at 8pm

I’d rather open at 8am, close on kernel upgrade.

At least that’s how I worked with my vim tmux sessions ;)

Hahahaha. A dev I work with who has been using eMacs for 30+ years is well known at my company for having eMacs sessions open for 6+ months at a time.

The way the other guy said. Then it breaks enough times, you give up, and switch to Helix. Nothing snappier out there (vanilla Vim included) and it comes with all the goodies you'd install 100 packages for (DAP, LSP, treesitter, sane default configs for dozens of languages)

To each their own, but for a hardcore Emacs user (wrote a number od my own plugins) that actually tried and couldn't seriously adopt VSCode for more than a few months, Helix was such a nice surprise + change of pace. Worth giving it a shot if you're caught in that gap.

Is there something that approximates org-mode outlining? I don't need all the other stuff org-mode does, but just the simple outliner functionality combined with all the other Emacs stuff is my golden handcuffs.

Not that I'm aware of just yet, unfortunately, so might be a good reason to stick around. For me the switch coincided with jumping on the zettelkasten train and I haven't looked back since. I miss some org mode fratures but constantly `org-refile`-ing I can do without.

https://imgur.com/a/i99Nisn

1.4 seconds for 100 packages, half of which are on probation? My (and soon `HYPER//MODERN`'s) package set is under heavy construction, I'll be sad if I don't get it under 300ms including loading and rendering a logo at 6k from a cold disk which that was.

Rust is a perfectly good language for writing tight code, but those `emacs` inner loops have been tuned by hard-ass pros for 30+ years in straight C, which is plenty fast too. Even the best Rust code doesn't have that kind of tuning in.

`emacs` is fucking fast.

With no intention to push back on Emacs being highly optimized, age of an application is not an accurate proxy for level of performance. If it were, grep would be faster than ripgrep. New software can apply optimisations discovered over the previous 40 years, and leverage architectural designs with different assumptions, like the GC limits in Emacs discussed elsewhere in the comments. Older applications can apply those same optimizations, but it's not a given that they will, and changing their architecture can be daunting, for sometimes unknown benefits.

I was about to answer "Use emacsclient", but then I realized you can't be bothered to configure it. For me, putting "(server-start)" into .emacs was always enough, but YMMV.

yeah, I can't deal with the emacs startup.

I mean, it's not slow per se, but compared to vim it's noticeably slower so I can't deal with it.

> But I can’t imagine switching my main axe up with a holy shit moment a lot crazier than tree-sitter in 2024 and not having the render loop be in JS.

Congratulations for winning HN sentence of the year before the end of January.

I’m glad I made a funny but it’s a lot of year to come :) And this one looks to be every bit as interesting as the last one was over-hyped.

It is a great sentence, and that holy shit moment is coming: when JS gains all the expressivity of tree-sitter and uses it to render code more beautifully than it has ever been rendered before.

(Spoiler: https://github.com/bablr-lang/)

> But I can’t imagine switching my main axe up with a holy shit moment a lot crazier than tree-sitter in 2024 and not having the render loop be in JS.

I can't parse this sentence -- could you unpack it? Not being a dick, I really want to know what you mean.

> (no one does this! it’s got a heap-size from the 80s!)

Shouldn't the devs do this? We're in 2024, embedded systems have more RAM, IO, etc than anything from the 80s.

The, uh, GNU folks, are a little conservative in some ways that surprise the mainstream developers. But there are always flags for it. Well, except stupid-ass dynamic-linking of `glibc`.

> are a little conservative in some ways that surprise the mainstream developers

Conservative is one thing, but having the default be something that's detrimental to 99.999% of your users in 99.95% of situations feels like bad defaults/design, not being conservative. My worthless 2 eurocents :-)

You would think that it would dynamically check the system on first run and set appropriate defaults.

> But emacs 29 with the right flags and a tuned GC (no one does this!

Please share how.

Both @darthrupert and @natyrys on the thread have said most of what I know. It's a little machine dependent to get the true sweet spot, but raising it from the like, megabyte (slight hyperbole) or whatever that it defaults to is the 80/20.

Ripped from my .emacs:

    (setq gc-cons-threshold (\* 100 1024 1024) ;; GC sometime after allocating 100Mb 
          read-process-output-max (\* 1024 1024)
          company-idle-delay 0.0 ;; company completions should be fast
          company-minimum-prefix-length 1
          lsp-idle-delay 0.1)  ;; clangd is fast
    (run-with-idle-timer 2 t (lambda () (garbage-collect))) ;; Trigger a GC after 5s of idle time

This is something of a hack of course, but it works & memory is cheap. You might want to push the GC threshold back down after emacs startup - a GC that fires early is a GC that does less work per invocation & is therefore less likely to cause perceptible stutter.

i got annoyed by emacs gc pauses and just disabled the gc completely (i think). haven't noticed any downsides so far. i'm in emacs all day...

    ;; don't garbage collect based on cons count
    (setq gc-cons-threshold 10000000000)
    (defun garbage-collect (&rest args)
     (message "trying to garbage collect. probably you want to quit emacs."))

something i love about emacs is everything is implemented in the same abstraction (of a "buffer of text"). so i can manipulate and move around an embedded terminal in the same way as a normal file, etc.

playing briefly with Zed it seemed like the terminal was a totally different "thing" than a normal file; i couldn't run the same text selection operations, couldn't split the window vertically or horizontally, etc. to me that loses a ton of the benefit of having a terminal in the editor in the first place.

still, it's a very interesting project. i have a very love/hate relationship with emacs, so i'm always interested in alternatives...

Can you share more about your Emacs 29 setup? Thanks

I mentioned it above but I’m flattered by your interest (and remember your username as someone serious): my old dots were ok and are floating around but we’re putting together a multi-editor curated setup for good defaults and an emphasis on good, available-weight models as first-class citizens.

It’s a 404 until I get to an RC, but aiming for March 1st on “hyper-modern.ai” for all MIT on emacs, nvim, and vscode.

Emacs still blocks input on simple things like package updates though.

Give straight.el (among others) a shot. Combined with use-package you don’t have to worry about that these days.

Ah ok. Last time I used straight it still blocked input on straight-update-all, didn’t realize they changed this.

There's a little tweaking sometimes.

Most examples you'll see of `straight.el`/`use-package` configurations will have some version of: `(use-package something-cool :ensure t :config ...`. The `:ensure t` clause will cause it to fall back on `package-install` in the event it's not bolted into your local Cargo-style-own-the-world-and-dont-break repo mirror. Disks are big, it's like the right default now.

But if you've got a package that's mis-specified in terms of where on `github` or wherever that `striaght` is supposed to find it, you can find it tapping `elpa.org` on the shoulder at a time when the UI thread is also doing blocking network IO.

The `Messages` and/or `straight` buffers will have warnings about this, so it's fixable to find the offending package and it'll stay fixed, but in fairness what you're describing is possible.

Elpaca [1] does not do this. I use it and it works a treat.

1: https://github.com/progfolio/elpaca

> There’s a market for people who want something snappier than VSCode but less labor-intensive to set up than emacs, and I wish them luck

Basically AstroNvim or Doom Emacs. Not a huge fan of Doom Emacs but AstroNvim got me to drop my main editors (Sublime + Atom) and I basically only use AstroNvim.

One enormous advantage of Nvim is that I can run it anywhere. I run it on a Linux machine, a Mac, and a Tablet (w/ Termux) extremely easy (just clone my dotfiles, install nvim, and that's it).

what are the right flags and gc tunings?

I don’t have much to add on what sibling @darthrupert said. You tweak this or that to your box but that’s an excellent guideline to start.

>>But emacs 29 with the right flags and a tuned GC (no one does this! it’s got a heap-size from the 80s!) is just as snappy and has more amazing packages than VSCode.

That explains my whole experience with Emacs. More time is spent in making Emacs awesome than actually doing my work.

I can't still figure out how can I get Emacs not mess up indentation and auto indentation.

Most language modes have a `foo-ts-mode` now that uses `tree-sitter` to get a perfect* AST in the absence of errors, and almost always the most reasonable one in the presence of errors. `tree-sitter` is amazing, a real feat.

It ships with 29 and it's work to find `brew` or `apt` or `nix` or anything giving you less than 29.1 these days.

Have you tried a recent version? 29.1 is dramatically more accurate on everything from syntax highlighting to indention than VSCode (IMHO, they're probably either using or working on using `tree-sitter` too, those are serious people) or JetBrains stuff (they're working on their vscode clone more than IntelliJ these days).

I only use `nvim` for commit messages and stuff the last few years, but AFAIK it has all the `tree-sitter` stuff too.

If it's the sloppy naming of `c-basic-offset-this` vs. `py-indent-that` or whatever (I don't even remember), try a good baseline distro like Doom and tweak from there.

Yes you are correct

Reply on news.ycombinator.com