Life is too short for a slow terminal

If your org doesn’t use mise, just add mise.toml to your global gitignore. Mise tries to be a single tool covering multiple needs, but don’t have to use it that way. I just manage toolchain versions and envvars (replace direnv).

Unrelated to Mise but related to zsh, there's also https://github.com/jeffreytse/zsh-vi-mode/issues/316. I noticed this plugin was causing a lot of delay. Learned a decent amount about zsh profiling from that issue.

Thank you for the recommendation, I might then also be able to ditch sdkman as well.

I run a scrolling WM and have settled into a habit of opening terminals when I need them, then closing them right after. I'll open a terminal, git pull, close it. Etc. I also use a terminal that launches cold in 10-20 ms, so it's not like a pay a price for it.

This is actually what I thought this post was about! But then I saw the Ghostty reference, which, in my experience, is not very fast to launch at all. I got it opening new windows quickly by running the main process as a systemd service, but Foot launches way faster without all that fuss, and allows you to go the daemon route if you want it _even_ faster.

EDIT: Just want to clarify, no shade on Ghostty. That project is cross platform and uses the 100% defensible decision to use the full GTK stack on linux. Foot is Linux AND Wayland only, and uses that very restrictive environment to optimize the hell out of startup and general performance.

I don't remember when I did it, but it looks like I must have gone through this at some point (maybe due to using GNU Make a lot? Or perhaps it was some other tool) - my zsh setup does a bunch of autocomplete setup only in the interactive case, and it seems to help a bit with startup time, at least on macOS:

    % for i in {1..5}; do /usr/bin/time zsh -i -c exit; done # zsh in interactive mode
            0.05 real         0.03 user         0.02 sys
            0.02 real         0.01 user         0.01 sys
            0.02 real         0.01 user         0.00 sys
            0.02 real         0.01 user         0.00 sys
            0.02 real         0.01 user         0.00 sys
    % for i in {1..5}; do /usr/bin/time zsh -c exit; done # zsh in non-interactive mode
            0.01 real         0.00 user         0.01 sys
            0.01 real         0.00 user         0.00 sys
            0.00 real         0.00 user         0.00 sys
            0.00 real         0.00 user         0.00 sys
            0.00 real         0.00 user         0.00 sys

That said, it is almost totally about the Z shell. So you might still qualify as 'weird' in this case on the alternative grounds of not using the Z shell. (-:

Developers that are very heavily invested in terminal and (over) optimize their terminal configuration are a small but very vocal minority.

In terms of speed, same thing: if you can provide some kind of objectively measurable thing, we can look into it. Everything we've measured so far firmly places Ghostty in the "fast" camp (with friends such as Kitty).

We're sometimes faster, sometimes slower, but in any case not noticeably so. You wouldn't pick Ghostty vs Kitty for example for performance, it'd be something else. But you would pick Ghostty over say... iTerm2 for performance (but you may pick iTerm2 for features, its extremely feature rich!).

You need to figure out what is going on because that certainly isn't normal.

Literally seeing 0.0% on Linux

I can't understand Ghostty either except as some kind of trendy memetic thing, the $GME of the TTY world.

I started using it expecting to love it, but in reality it didn't seem to gain me anything but in fact was worse in several major ways. Also less configurable than Iterm2. :/

    if [ "$SESSION_TYPE" != 'remote/ssh' ]; then
     if [ "${TERM_PROGRAM}" != 'tmux' ]; then 
      ( if [ $[RANDOM % 10] == "0" ]; then fortune -n 40 -s; else echo "Hi, $(whoami)!"; fi ) | cowsay | lolcat && printf '\n'
     else
      if [ "${TMUX_PANE}" == '%0' ]; then 
       fortune | cowsay -f small | lolcat && printf '\n'
      fi
     fi
    fi

But what would life be without a little bit of fun?

— Kurt Vonnegut

"The terminal itself

Shell startup is only half the story, because the emulator adds its own input latency. I use Ghostty, which is GPU-accelerated and native, and my config is just seven lines long."

I do not use Ghostty or anything similar^1

1. https://en.wikipedia.org/wiki/List_of_terminal_emulators

Further, the terminal emulator cited by the blog author requires a graphics driver

I do not use a graphics driver

Yes you do. It's the one built into your operating system's kernel. You'll find a lot of, but not all of, its code in /usr/src/sys/dev/wscons .

I use the vga driver which does not do graphics

I started to take your comment seriously until that line. You're avoiding leveling up and learning how to use the CLI. Whatever reason you are avoiding it for, understand that's what is at play here.

If you start 1 command and get 1 output, the terminal isn't particularly powerful.

One you do start combining commands then it's a totally different thing.

If your GUI does everything you need, then a terminal isn't necessarily useful. If your GUI doesn't provide a feature though, you are most likely stuck. You might be able to learn it's own API in a specific language, e.g. Lisp for Gimp, Python for Blender, etc. If though your terminal application doesn't provide what you need you can pipe its output to another terminal application and thus get something that none of those applications individual can. Once you have done it with 2 applications you can do that with 3, 4, etc. You can label those applications and re-use that tomorrow, share with someone else, etc.

The terminal isn't about starting one application.

In practical design, GUI applications inevitably deprecate keyboard abstractions in favor of graphical abstractions and graphical abstractions require parsing visual representations and are less conducive to "muscle memory" whenever pointer control is relative rather than absolute (which these days is approximately always [1]).

Keyboard oriented applications feel more like a language and human brains tend to map well to language and touch typing while GUI's rely on something akin (or identical) to hand-eye coordination. Hand-eye coordination is harder than touch typing and every GUI application requires developing a unique mental model.

[1] in the ancient days of digitizing tablets with absolute coordinates, it was possible to "touch mouse." But that's not how we do things today (and it would not work well with infinite scrolling, etc.)

Of course, other tasks are nicer with a GUI and/or mouse/tablet/touchscreen (art creation for example).

Here are some advantages.

  - It is repeatable, you can do the same exact thing you did before. With ZSH history + FZF, recalling a command is a breeze.

  - Auditability. The command in your shell history is there for you to revisit and servers as a permanent record of something you did (or didn't do).

  - A command line doesn't make a mistake at 10th time, due to fatigue, inattention etc.

  - Reusability. You may have to repeat the same command for different folders (or remote servers). A slight modification of the previous command will do it for you.

my take is terminal is just quicker than "gui".