Pavel Fatin

This is from 2015, but emacs still has higher typing latency than vim in 2024. https://pavelfatin.com/typing-with-pleasure/ If you have better numbers and comparisons for emacs keypress-to-pixel latency, etc. I'd be interested. Note classic vi started up faster than vim. Device makes little to no difference: Raspberry Pi 5, MacBook Pro M1, ThinkPad P1, etc. - emacs is clunky on all of them. I like emacs and it's my daily driver. But it isn't fast. see also: "Computer latency: 1997-2017" https://danluu.com/input-lag/ "Measuring keyboard-to-photon latency with a light sensor" https://thume.ca/2020/05/20/making-a-latency-tester/

I don't care about memory usage for editors as much I care about input latency and responsiveness. Jetbrains (IDEA IntelliJ, Pycharm, etcetc) put a lot of effort into making their IDE low latency as it was getting to a point of being almost ridiculous. Their editor is built in Java, and they run on their own runtime as they have so many hacks and tweaks to make it work as a desktop app as well (font rendering, etc). Pavel Fatin has a [great article](https://pavelfatin.com/typing-with-pleasure/) about typing latency and his work around implementing this in IntelliJ, well worth a read.

Here's a great investigation of the latency of getting characters on the screen once you type them. https://pavelfatin.com/typing-with-pleasure/

It's possible you and your acquaintances can't tell. Similarly some people claim they can't tell a difference between a 720p video and higher. Or that they can't tell a difference between 128 kbps CBR MP3 and higher. However the differences are real and have been measured. [1] [2] You are welcome to argue that the performance work isn't worth prioritizing, but don't fall into the trap of claiming the performance gap doesn't exist. -- [1] https://pavelfatin.com/typing-with-pleasure/ [2] https://danluu.com/input-lag/

Another great deep dive into latency of typing is this one [1] which considers input latency from the keyboard, the keyboard interface, the editor/IDE, and even the window manager. Pavel found that Windoes Aero added 16.6ms extra latency (but this has probably been fixed by now). [1] https://pavelfatin.com/typing-with-pleasure/

What was Atom good for, when compared with something like Visual Studio Code? I recall reading about typing latency and it seemed to come out as one of the slower options: https://pavelfatin.com/typing-with-pleasure/ I guess it would have occupied a similar place as Brackets, another vaguely similar project? https://brackets.io/ Then again, with how popular VSC has become and with how insanely many extensions there are for it, using any other editor feels a bit... counterproductive at times? Personally, i'm using the following: - CLI: nano (vim works too, I just like the simplicity more) - Simple text editing: Notepad++ or similar (usually whatever is on the system on *nix) - Some scripting, but nothing too serious: Visual Studio Code - Development in larger and more complex codebases: JetBrains products (e.g. IntelliJ IDEA, WebStorm and so on)

>Do you have any basis for this "best in class" claim? Take a look at these benchmarks https://pavelfatin.com/typing-with-pleasure/#linux

Modern day tools such as Slack, VS Code and other Electron & browser based apps do bring a fair amount of lag into day to day work. The common denominator there is browser tech & I think that will improve with time. And network-delivered services like Google Maps & Wikipedia are best compared to CD and DVD-ROM based services like MapPoint and Encarta, which had their own latency and capacity challenges. In the meantime, you can still use tools like vim for low-latency typing. And it’s kind of interesting to see a Java GUI (IDEA) perform as well as it [has](https://pavelfatin.com/typing-with-pleasure/).

I think that https://pavelfatin.com/typometer/ gets close to checking the actual perceived quickness of a terminal. It measures the time from keyboard signal to pixels on the screen. I would much prefer a terminal that still provided interactivity when text was scrolling in other parts than raw speed. Open up two panes in tmux or your favorite split screen with text scrolling in one and measure latency in the other pane with typometer and I will use whatever comes up to the top.

further reading: https://pavelfatin.com/typing-with-pleasure/ https://danluu.com/keyboard-latency/ In Windows 7, classic mode disabled the DWM compositor and V-Sync. It's incredibly dumb that Microsoft would arbitrarily remove that feature in Windows 10 to push their ugly as sin post-metro UI.

I recommend reading this: https://pavelfatin.com/typing-with-pleasure/

Approaching the subject another way, Pavel Fatin's excellent article Typing with Pleasure (https://pavelfatin.com/typing-with-pleasure/) goes really (really) deep into another way in which text editor performance can be compared

I love the concept of Atom and have a lot invested in its success. That being said, I switched back to Sublime because of the responsiveness, and here's why: Programming (for me) is a craft. When I'm in the flow of coding, there's a conversation between me and my program, mediated through the editor (and my REPL). Even a subtle typing lag is enough to subtly disrupt that flow state – the speed of thought and text no longer coincide, and that slight, almost subliminal perception of delay build into a sense of frustration and just being out of sync with my program. It's a problem that's most noticeable in its absence. Like when you go to the gym for the first time in a while and realize "oh, yeah, this feeling is what I've been missing", switching from Atom back to Sublime feels... right, refreshing. For a great analysis of typing latency, and why it's important, see: https://pavelfatin.com/typing-with-pleasure/ (I am happy Atom is still moving forwards, though, and eagerly await the day I can switch fully from Sublime. Easy modification of ones own tools is another big component of my personal programmer-as-craftsman ideal.)

> What is your use case that you see UI lag between vscode and sublime? … I think this is … posturing … Typing with pleasure: https://pavelfatin.com/typing-with-pleasure/ Study the graphs. Ready the copy. If you don't feel these differences every keystroke, count yourself lucky to have slower perception or typing, rather than accusing folks of posturing.

> Are you telling me that it was a delay when you type in vscode? If so, either your configuration or computer is doing something wrong This is simply not true. There is inherent latency in any rendering pipeline, and VSCode and Atom both have input latency that is significantly higher than other editors like Sublime Text owing to a bloated rendering pipeline. You can read more about this and how easy it is to introduce latency simply by changing basic things like keyboards here: https://danluu.com/input-lag/ or editors specifically: https://pavelfatin.com/typing-with-pleasure/

JetBrains IDEs with their zero-latency typing mode are actually some of the most responsive editors for typing performance: https://pavelfatin.com/typing-with-pleasure/ They can definitely feel a bit sluggish navigating around once you have a giant codebase and you’re using a lot of features, but code editing has been very responsive for me.

I can't think of a more bloated way to communicate than putting a browser in the middle. For some quick numbers, compare web browser input latency to terminal [0] where one might run an IRC client. Even emacs [1,2] is fast and light in comparison. [0] https://beuke.org/terminal-latency/#:~:text=6.2-,firefox%20(121.0.1-1)… [1] https://danluu.com/term-latency/#:~:text=terminal.app%20and%20emacs-es… [2] https://pavelfatin.com/typing-with-pleasure/#:~:text=0.8-,Emacs,19.2,-…

You might like Typometer. I believe it was created by a JetBrains developer to improve input latency in IDEA. > Typometer works by generating OS input events and using screen capture to measure the delay between a keystroke and a corresponding screen update. Hence, the measurement encompasses all the constituents of processing latency (i. e. OS queue, VM, editor, GPU pipeline, buffering, window manager and possible V-Sync). https://pavelfatin.com/typing-with-pleasure/

Expanding on this, there's a detailed analysis of the various contributors to editor latency (from keyboard electronics to scanout) by one of the jetbrains devs at[1]. They show average keypress-to-USB latency for a typical keyboard of 14ms! 1: https://pavelfatin.com/typing-with-pleasure/

here is some latency tests using an external camera, though that's Windows only, there might've been a similar one for Linux, but not sure https://chadaustin.me/2024/02/windows-terminal-latency/ The other one where xterm is uber low is https://lwn.net/Articles/751763/ is using this tool with software-based screen capture https://pavelfatin.com/typometer/, not sure how reliable that is as a proxy for end-to-end (at the time of the benchmark Wayland wasn't supported)

According to one benchmark intelliJ can reach an average latency of 3ms on an i5 3427U from 2012 [0]. In a 2022 Github issue someone profiled VS Code which resulted in 12ms latency on an i7-12700KF released in 2021 [1]. If those results are even remotely representative of real-world scenarios then VS Code can't come close to intelliJ performance. [0] https://pavelfatin.com/typing-with-pleasure/#windows [1] https://github.com/microsoft/vscode/issues/161622#issuecomment-1287528…

>if the system I'm using has excessive latency (more of a 90s problem than today) Hmm? If anything a lot of modern software is worse even from 80s latency, from extra processing going on in the editor, all the way to inefficient polling and scan rate in keyboards, USB latency, monitor refresh latency (next frame, 60fps = ~16ms wait if you're unlucky and press towards the start of a previous refresh) and so on. And that's not even accounting for extra layers like Electron. https://pavelfatin.com/typing-with-pleasure/

> Vim is only slightly slower Both vim and neovim (be it in TUI or GUI form) are faster than Emacs. https://pavelfatin.com/typing-with-pleasure/#summary

> I recently tried using a 486 + CRT monitor setup. The speed at which your keystrokes appear on the screen is simply astounding. Use a fast editor like Sublime Text or even something like JetBrains IDEA with the zero-latency mode enabled and the editor delay will be single-digit milliseconds. Get a modern 120Hz or more monitor (search for gaming monitor) with low latency and your display lag will be less than 10ms. More info here: https://pavelfatin.com/typing-with-pleasure/

I have absolutely no use for a code editor with a typing latency as high as vscode. Anyone who has not read https://pavelfatin.com/typing-with-pleasure/ is doing himself a disservice.

The only benchmark I could find is https://pavelfatin.com/typing-with-pleasure/#editor-benchmarks , showing GVim to be quite a bit better than that. For terminal Vim, terminal latency dominates.

Not sure if it's relevant but I liked the approach of Pavel Fatin in measuring editor latency [0]. It uses OS level input events and actual rendering on screen. So testing the same editor/file with different settings might yield results that are different depending on your scheduling config, while staying close to a "real world" example. He shared [1] the tool he made for the tests. I'd be curious to know your results regardless of the technique used. [0] https://pavelfatin.com/typing-with-pleasure/ [1] https://github.com/pavelfatin/typometer

20ms latency is about average for a text editor: https://pavelfatin.com/typing-with-pleasure/ (Not that that's a good thing...)

https://pavelfatin.com/typing-with-pleasure/#editor-benchmarks Atom is the Electron-based editor from GitHub. It's way slower than the others. I can't think of any Electron apps that have low response latency. VScode's is noticeably much higher than, say, Emacs.

Direct link to the section with Windows results: https://pavelfatin.com/typing-with-pleasure/#windows Scroll a bit down for Windows with power saving, Linux (section 3.4), and VirtualBox (3.5).