There are a number of network protocols that we might refer to as text protocols, where we send a line of text to the server and it sends back a response. Perhaps I should call them CRLF protocols, to distinguish from protocols where we’re blasting JSON back and forth. To speed things up, it can be tempting to have the client send multiple requests without waiting for individual responses.

more...

Apple released “Liquid Glass” which looks a lot like a revival of UI fashion from two decades. Everything is transparent. But I doubt Apple has the courage to bring back wobbly windows. No matter, I hardly move my windows around anyway, but what does move is the text inside. So why not wobbly letters? Wobbletters. Definitely in the category of felt cute might delete later.

My original idea was to add a little spin to each letter as it scrolls. Like the letters are hanging on a backboard, and as it bounces up and down, momentum is transferred to the letters. Didn’t quite make it that far, but maybe next time.

To start, I just wanted to check I could shift the vertices around a bit. The same wobble for every vertex, no distortion.

        var wobblex, wobbley float32
        if smoothAmt != 0.0 {
            wobblex = (rand.Float32() -0.5) / 50.0
            wobbley = (rand.Float32() -0.5) / 50.0
        }
        for k := 0; k < 6; k++ {
                base := &baseverts[x+k]
                base.adj[0] += wobblex
                base.adj[1] += smoothAmt + wobbley
        }

This ended up looking much cooler than I thought. Like a faceted glass privacy screen. Apple should totally add this now. It fits with the glass theme. The sequel to liquid glass, solid glass!

Unfortunately, this renders the text unreadable while scrolling.

Video is at 30 fps, but the illusion is more complete at 90 fps. You no longer see individual letters, just transient edges as they pass by.

<video playsinline controls poster="/images/wobble.jpg">
<source type="video/mp4" src="/images/wobble.mp4">
</video>

Accidentally rebooted after installing this, so I guess it’s wacky week for a while.

X11 is supposed to be dead, but people keep using it because apparently it still works. I have a plan to fix this so everyone does what I want.

It all starts with a popular toolkit library like QTK. Even if people don’t upgrade X11, if they run a browser, they’re on the upgrade treadmill.

I change the internal pixel representation from RGB to BGR and adjust the Wayland backend, but not the X11 backend because that’s community supported.

I am confused when bug reports start coming in. Weird colors on X11? Doesn’t surprise me, there’s tons of weirdness in that pile of jank. Works for me in Wayland, you should try it.

Somebody will figure it out and submit a patch. I’m sorry, but we have a release scheduled and we can’t merge anything that may cause further regressions, even though it only changes x11.c. Are we sure this is even the correct fix? Have you tested with a Voodoo2 card?

This is the internet, so after sufficient slow walking, someone is bound to say something unpleasant on the tracker. I write a blog post outlining how not only is X11 support a burden on developers, it’s literally unsafe. Just look at these death threats.

I commit the fix with a lengthy commit message fanfic story about frogs and scorpions and the Jem’Hadar.

I revert the BGR change back to RGB pixels. I write another blog post expressing regret about the lack of progress and alluding to all the cool things that would have been possible, if only we weren’t held back by legacy platform support. No need for details, people will get the message.

Users start reporting bugs on X11. Weird colors on X11? Again? How many times do we need to fix this crap? We need to get people off of X11, whatever it takes.

I devise a plan to kill X11.

Back in the olden times, software was hard to build and hard to use, but remarkable improvements have been made, and entire ecosystems of ergonomic languages are now available. I happen to think the old ways still have some merit, but don’t want to spend all my time staring at the cave walls.

more...

It’s been three years since our previous counting of lines, so let’s check back in and see how OpenBSD is growing. Instead of just looking at the kernel, this time we’ll zoom out and look at the entire src tree.

. 20.54M lines 954.56M bytes
├──sys 9.70M lines 627.17M bytes
│  ├──dev 8.49M lines 593.52M bytes
│  │  ├──pci 7.14M lines 549.14M bytes
│  │  │  └──drm 6.58M lines 532.33M bytes
│  │  │     ├──amd 5.81M lines 509.00M bytes (7)
│  │  │     └──(other) 696.08k lines 21.03M bytes (7)
│  │  └──(other) 1.33M lines 43.74M bytes (36)
│  └──(other) 1.21M lines 33.66M bytes (22)
├──gnu 7.65M lines 238.82M bytes
│  ├──usr.bin 4.72M lines 140.19M bytes
│  │  ├──binutils 1.42M lines 42.64M bytes (12)
│  │  ├──binutils-2.17 1.14M lines 39.34M bytes (12)
│  │  ├──gcc 1.18M lines 35.25M bytes (3)
│  │  └──(other) 981.74k lines 22.96M bytes (5)
│  ├──llvm 1.52M lines 55.85M bytes (8)
│  ├──gcc 1.25M lines 37.88M bytes (11)
│  └──(other) 164.69k lines 4.89M bytes (3)
└──(other) 3.19M lines 88.57M bytes (12)

As some of the more knowing members of the audience may have predicted, the AMD GPU driver wins the prestigious Most Growth award, nearly doubling in size. It’s gone from being more than the half the kernel to more than half of the entire operating system. Quite the achievement! No other subdirectory even comes close.

AMD was up against some stiff competition in the past, including Team Toolchain featuring two copies of binutils, two copies of gcc (4.2 and 3.old), and llvm, but even their combined efforts now come in at only half an AMD.

There are some other programs and utilities included in OpenBSD as well, but at less than 10% of the codebase, they’re probably not worth further consideration. Too far out of competition.

I haven’t had much use for Windows for a while, but I like to keep abreast of whatever fuckery Redmond has in store for everyone else. I picked up a new laptop with the dreaded Copilot key, and thus had to figure out how to make it useful. And along the way, found a bunch of other settings to adjust. The plan is that I won’t need any of this knowledge until it becomes obsolete, but the only way to ensure that outcome is to write it all down; thus by being available it will never be necessary.

more...

I didn’t realize I needed this until I implemented it, and now, oh wow, can’t imagine life without it.

more...

Another month of poking around trying to make an almost useful terminal emulator.

more...

I wrote my own terminal and you won’t believe what happened next. I called it vertigo.

more...

The monaspace fonts introduced the idea of texture healing. I think of it as a sort of kerning for monospace fonts, though there’s probably some reason that’s technically incorrect. The basic idea is that some letters want more space, while others want less space, but this is hard to achieve in a monospace grid. And so they made a special font that includes alternative glyphs for letter pairs, so that i can donate some space to m.

more...