Have you tried Ratpoison? It's got a bunch of features to manipulate the rat with the keyboard.

If ratpoisons features aren't enough, stumpwm might work well, it's like ratpoison with lisp.

Cagebreak is like ratpoison for Wayland. (I haven't tried it.)

I suspect awesomewm might be a good candidate too. I messed around with trying to make it more ratpoisony. The results were pretty good.

Just yesterday when I saw the Leonhart French video about the NVIDIA piracy case.

Have you tried LXQt? It made things easy for me when Plasma 6 broke a KWin script I was using to improve the multihead experience.

I use LXQt with virtual machines, is it good for using on bare metal too?

I only used it on bare metal, worked fine.

I don't recall the exact name, but I believe it's forward-up-sexp which allows you to jump forward past the next closing delimiter. Though if I'm not mistaken only the backwards one has a default binding.

And yet Heineken had a €23 billion revenue in 2019.

Touché

As someone who likes games from various periods (from Ultima IV to WH40K: Rogue Trader), I haven't ran into many games which do work on X11 and don't work on Wayland. Though I don't really have any of the old Loki games (I believe there was a port of Unreal Tournament?), so I might be missing out on the specific games which really lean into certain X11 features which XWayland doesn't support well.

> If there's one thing that I sometimes wish Lisp had, it's types.

Let's write some very silly code to turn an integer into a list of digits in Common Lisp:

  (deftype Digit ()
    "A non-negative integer smaller than 10."
    '(Mod 10))

  (defun integer->digits (integer)
    "Turns a given INTEGER into a list of digits."
    (declare (type Integer integer))
    (labels ((digit-loop (integer digits)
                (declare (type Integer integer)
                         (type List digits))
                (if (< integer 10)
                    (list* integer digits)
                    (multiple-value-bind (quotient remainder)
                        (truncate integer 10)
                      (declare (type Integer quotient)
                               (type Digit remainder))
                      (digit-loop quotient
                                  (list* remainder digits))))))
      (declare (ftype (Function (Integer List) List) digit-loop))
      (digit-loop (abs integer)
                  nil)))

  (digit-loop 2026) ; => (2 0 2 6)

  (digit-loop "2026")
  ; The value
  ;     "2026"
  ; is not of type
  ;     INTEGER
  ; when binding INTEGER
  ;
  ; Type HELP for debugger help, or (SB-EXIT:EXIT) to exit from SBCL.
  ;
  ; Restarts:
  ;   0: [ABORT] Exit debugger, returning to top level.

Yep, I know, but most Lisps do not have those declarations available and even in CL they aren’t used very often. But yes, they would help in CL.

All programming languages have horrible syntax (except maybe Forth). Some examples:

Statements are terminated by either a dedicated graphical character, in which case it's easy to forget the character and have a problem, or by a newline (or maybe a different white space character, but I haven't encountered that yet) in which case decent formatting of code may require a dedicated graphical character to indicate that the newline DOESN'T terminate the statement, in which case we have the same problem. Having newline-terminated statements without continuation character would be consistent, but would hamper readability because identifiers would need to be strictly limited in length to keep certain lines from exceeding available screen space (or alternatively readability would suffer from lines only being partially readable).

And that's before getting into the weeds of how mathematical notation is tricky (most people have learned infix notation at maths class in school, so they mightn't appreciate how horrible it is), how different types of brackets (round, square, curly) can have inconsistent semantics, the downsides to the various ways of indicating lexical blocks (brackets, white space, keywords,...), et cetera.

The ideal programming language would probably be one which allows switching between different syntaxes based on what works best for the user (for example, someone could write code in S-expressions, another person could have that code automatically translated into SRFI-119 Wisp expressions and work with it like that, a third person could then have it rendered into something more Lua-like,...). Which is something I think the Racket people are working on, but I may be mistaken.

Apparently (<https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher...>) Heroic supports launching games with DOSBox Staging or ScummVM.

Before I upgraded to my new PC (managed to get it just before AI sent prices into the stratosphere), I was using an older PC (2016~ish) without discrete GPU. It ran Plasma Wayland without any problems. My new PC (has an RX 7600) also runs it without any problems. I don't know what's wrong with your PC (I mean, AlienWare does make atrocious garbage, so it could be anything), but I expect it to run better on your lesser PC's/laptops.