Tomscii

This is also great: https://tomscii.sig7.se/2021/01/Typing-latency-of-Zutty The typing latency on zutty is the biggest feature for me. Everything feels snappy.

Cool article! Where did you learn PSU design? Are you "classically" trained or self taught? edit: The article on the design of the PSU is also great: https://tomscii.sig7.se/2024/04/300W-Linear-DualTracking-Lab-PSU

Why no love for Zutty (https://tomscii.sig7.se/zutty)? It's far more feature-complete than Kitty or Alacritty, without sacrificing much in way of performance or latency.

kitty has lower latency than Alacritty. Alacritty is optimized for throughput and is the best for that, but I don't understand who would prefer throughput over latency in a terminal setting. I switched from kitty to wezterm. I don't have an official benchmark like the below [1], but low latency is an explicit goal of the project and it seems on par with kitty. [1] https://tomscii.sig7.se/2021/01/Typing-latency-of-Zutty

https://tomscii.sig7.se/2020/12/A-totally-biased-comparison-of-Zutty is also useful as a comparison piece.

I can pronounce the name of this software correctly. Now that's something I guess. https://tomscii.sig7.se/zutty/wiki/FAQ.html#How%20do%20I%20correctly%2…

The post just before that one... https://tomscii.sig7.se/2024/10/Synchronous-buck-converter-12V5A

Diagram of the bare circuit board. So you can see the overhead view of the run from VIN to Q5 that blew. https://tomscii.sig7.se/images/linear-dual-lab-psu/pcb-front.png Edit: I'm not the writer of the article...

Compared to a similar 6yo [1] and 3yo[2] (by zutty maker) comparisons, VTE terminals still (at least pre-46) bad in latency front. (They're as high as VS Code based beuke article.) Xterm still rules it. (Pointed in [2], this is due to direct rendering via Xlib which comes with the downside of having poor throughput.) Alacritty significantly improved, Konsole got worse. About Alacritty, it's pointed in [2], there were various opened tickets related to its poor performance and wasn't an easy to solve problem. So kudos to Alacritty devs for succeeding and GNOME devs for improving in the new version. Alacritty, Kitty, Zutty, GNOME, others, quite a rejuvenation in terminal development. [1]: https://lwn.net/Articles/751763/ [2]: https://tomscii.sig7.se/2021/01/Typing-latency-of-Zutty

Your benchmark is more than 6 years old, on a 2014 Macbook, with a strange choice of terminals. LWN's article on the subject is almost as old, but with a better comparison: https://lwn.net/Articles/751763/ (2018) For a recent take, though by one of the competitors, see https://tomscii.sig7.se/2021/01/Typing-latency-of-Zutty > TL;DR; terminal.app on macOS is typically the fastest. Even on macOS, that's probably not true, at least nowadays. See https://www.lkhrs.com/blog/2022/07/terminal-latency/ (2022)

No one is "hating" on Grafana. But if you used tools of the past, you'd know how light they were compared to the Grafana/Kibana/Elastic mongrel. But I should mention that there is nothing "stupid simple" about the solution of the OP. Just look at the install procedure... https://tomscii.sig7.se/umon/

zutty has an interesting article how it does it. https://tomscii.sig7.se/2020/11/How-Zutty-works

I favor kitty[0] and zutty[1]. Gnome terminal / libvte is and has always been slow, and alacritty might have good throughput, but sadly is high latency. 0. https://sw.kovidgoyal.net/kitty/ 1. https://tomscii.sig7.se/zutty/

st is such an outlier in those measurements that it makes you wonder whether something is potentially wrong with the test setup. There's another set of latency measurements here: https://tomscii.sig7.se/2021/01/Typing-latency-of-Zutty In those, st is roughly similar in performance to urvxt and Alacritty.

The zutty project had an interesting article on terminal latency, as well: https://tomscii.sig7.se/2021/01/Typing-latency-of-Zutty

Zutty is also cool: https://tomscii.sig7.se/zutty/ It's correct (like XTerm) while still being very fast.

There are various ways to take advantage of the GPU -- the so-called GPU-accelerated terminals contain bespoke OpenGL programs ("shaders") to do rendering on the GPU. Here's an interesting way of doing it: https://tomscii.sig7.se/2020/11/How-Zutty-works

Homepage: https://tomscii.sig7.se/zutty/

I like the focus on simplicity of uMon, and agree with author's criticism of behemoths like Grafana. But looking at the installation instructions[1], I can't help but think that their reluctance to use Docker feels contrarian for no reason (and the quip about it being "out of fashion" completely misguided). This whole procedure could be automated in a Dockerfile, and actually running uMon would be vastly simplified. Docker itself is not much more than a wrapper around Linux primitives, and if they dislike it specifically for e.g. having to run a server and run containers as root, there are plenty of other lighterweight container alternatives. There's an argument to be made that the "Simple" Network Management Protocol they're a fan of is far from being simple either[2]. Configuring the security features of v3 is not a simple task, and entire books have been written about SNMP as well. They conveniently ignore this by using v2c and making access public, which might not be acceptable in real-world deployments. I'm all for choosing "simple" tools and stacks over "complex" ones, for whatever definition of those terms one chooses to use, and I strive to do that in my own projects whenever possible, but simplicity is not an inherent property of old and battle-tested technologies. We should be careful to not be biased for technology we happen to be familiar with, but be pragmatic about picking the right tool for the job that fits our requirements, regardless of its age or…