I used a website called Trakt for this and it worked well enough. All I really wanted was a list of stuff I’d watched ordered by date and by rating (two lists, like) and it did that fine.

Recently, they seemed to enter the “we’ve got a load of users, let’s paywall everything in the guise of a ‘UI redesign’” phase of their development cycle.

I could just move to whatever web service people are moving to instead, but the same thing would happen, it would be temporary. Or maybe Trakt will relent in the face of everyone hating the ‘redesign’, but the same applies.

When we use these things we’re at the whim of what some techbro bellend thinks will be profitable. It’s always temporary, the rug will always be pulled.

It’s not even like Trakt was doing anything clever, for my use at least, just a list of films/shows with dates and ratings. So I decided to replace it with a bash script (yeah, I know, I’ll get off Gitlab soon).

I exported my ‘data’ from Trakt, which was all in horrible json. I did some jq magic (i.e. guesswork) and got the stuff I cared about into a single tab-separated file.

Now I can just go rate "White Men Can't Jump" 1992 10 in a terminal and the script takes that, sticks it in the tsv file with today’s date, generates a couple of very basic html pages and uploads them to this server. I also made it so I can just update in case I want to stick stuff in the tsv manually.

I’m not suggesting anyone else use this script, it’s not particularly well written and is tailored very much to my use. But it only took about an hour, works better than Trakt ever did for me and will work forever.

What is it “fonts”?

Back in the olden days, when computers mainly did text, screens were divided into rows and columns of characters, and characters were rows and columns of pixels. And that’s what a pixel font still is - characters drawn in a fixed-size grid with pixels that are entirely on or off.

In the modern times we have fonts that are made of curves rather than pixels. Vectors, as the kids call them. Screens, of course, are still made of pixels, and you can’t really do curves on a pixel grid, you can only, with some fancy maths, approximate them. The higher the density of pixels, the closer the approximation gets, but it’s always an approximation. Or, in other words, a disgusting and shameful lie.

When you’re sending sinuous curves through a pixel grid, sometimes the curve will pass through half a pixel. Is that pixel on or off? What you got, particularly on relatively low-density screens relative to the font size, was often a bit of a fucking mess.

But then font-boffins invented hinting, whereby the font contained information as to whether, when a curve passes half-way through a pixel, that bit of the letter is more inny or outie and, therefore, whether that pixel should be on or off.

And we carried those boffins through the streets on our shoulders. Statues were erected and songs were sung. Finally our letters could be more roundier, without bits sticking out in weird places. “But wait!” someone in the crowd shouted, “The letters are still jaggy!” The scales fell from our eyes and we kicked the boffins to death for their wicked pride.

Their progeny continued their diabolical work and invented anti-aliasing: What if, when those curves pass partially through a pixel, instead of making it either black or white, we sometimes made it in-between, deceiving thine eyes into seeing something smooth.

So, to display a letter in a pixel font, the computer asks the font: Is this pixel on or off? And the font replies either “on” or “off”. Computers love this, since “on or off” is their native language.

To display a vector font, the computer asks the same question, and the font replies: It’s complicated, here’s a lot of difficult maths homework.

Does this extra work really matter on a modern computer? No, not at all. But it does add complexity - you generally need libraries to do all that fancy font maths.

Who the pixels though?

One thing that pixel fonts are objectively, undeniably better at is being legible at very small sizes. While the notable downside is that they can’t really be resized, you get what you’re given in terms of font sizes.

There’s a certain kind of dickhead productivity-maxing programmer-type who just wants to have as much text on screen as is humanly possible, so many of the modern pixel fonts prioritise clarity at absurdly tiny sizes.

I’m not interested in that and my eyes are too old for it anyway, I just want a nice, crisp pixel font that looks decent at normal sizes.

I tried a handful of these and found them mostly lacking - they tend to not have enough sizes (I want to ‘zoom’ in on my terminals sometimes), look inconsistent at different sizes or, often, both.

So I settled on Terminus, which is very much the de facto default of pixel fonts (suiting my drive for basicness). It’s not, to my eyes, the most attractive font - I like my serifs and my curly gs and ks - but it’s decent enough, comes in loads of sizes and looks consistent across those sizes.

So as to be using it though???

I’ve been using Terminus as my terminal font for a week or two now. It’s very geometric when I tend to favour something a bit humanist or irregular-leaning neo-grotesque, but I got used to it fairly quickly and quite like it now. Despite being very regular, it does have a touch of personality, particularly in the letters with descenders (which might just be a function of fitting the pixel grid but I like it nonetheless).

And something I thought might happen has happened - vector fonts at body-text sizes, particularly in terminals, look unpleasantly blurry/fuzzy to me now.

Since your eyes probably haven’t beheld the glory of pixel fonts as mine have, you probably aren’t seeing that as I am. Here’s an artist’s impression of how that looks to me.

Summerly

I like my pixel terminal font. I will be sticking with it. The crisp clarity seeps into your eyes like honey spat through a sieve by an elderly bigot.

A pedantic aside

What we tend to refer to as a font is actually a typeface. For example, Comic Sans is a typeface not a font. A font is a typeface with particular characteristics (size, weight, etc.). Comic Sans in bold at 12pt is a font. I’m not arguing that the ‘correct’ usage should be pushed, that battle is lost, just might be interesting for anyone not aware of the distinction.

So let’s do that! Here are some things that I enjoyed for the first time in 2025 probably, regardless of when they were made.

I’ll mostly lean towards less obvious stuff cos it’s fairly pointless highlighting stuff everyone knows about. With the exception of…

Pluribus (2025) (tv)

Everyone knows about this one already. I’m sure we’ve all had plenty of people telling us to watch this. But, for once, they’re right!

It’s like they took a good Star Trek episode premise with its interesting sci-fi situation and all the philosophical questions and ethical conundra that entails, span it out into a full series, and then made it very character focused. It’s slow in a rewarding way, intentional and darkly funny.

What did we learn?

• Don’t(?) shout at it

Dinner in America (2020) (film)

You won’t believe me 20 minutes in but this is the most charming, heart-warming romance I’ve seen in forever. I was blubbing for the last 1/3 or so.

Two misfits meet and stuff happens. I don’t want to say anything. Just watch it.

What did we learn?

• You are punk as fuck

Beyond the Infinite Two Minutes (2020) (film)

A fella works in a café and discovers that the TV in the café and the monitor in his flat above are connected, but the TV in the café is two minutes in the future.

It’s all presented as a continuous take which gives it a nice kinetic feel as the characters get their heads around the intricacies of the time paradox.

It’s very playful and a ton of fun.

What did we learn?

• Japanese monitor cables are really long

The Great Villainess: Strategy of Lily (2025) (game)

Imagine if they took JRPG turn-based combat but somehow actually made it fun. Impossible, you say, and I would’ve agreed, but they’ve only gone and bloody done it!

Narratively it’s about a crazed noble, Scarlet, who’s launching a rebellion against the king or emperor or something. You play as Lily who’s tasked with reining in Scarlet’s more genocidal tendencies (or not) and winning the war while also… streaming the battles and gaining followers. It’s quite silly. The dialogue’s witty and engaging and, unusually, there’s not too fucking much of it.

There’s a strategic overmap which actually has some nice strategy to it due to a cool supply-chain mechanic. And battles themselves are only three turns, which transforms what’s usually a spam-best-attack slog into something very intentional and thoughtful.

What did we learn?

• The revolution is televised

Under the Silver Lake (2018) (film)

An odd, hazy, symbolist polemic. Playfully dissects our relationship with entertainment in general and celebrity and Hollywood in particular. Sort of oozes in and out of the aesthetics and forms of classic Hollywood in a way that reveals within them a looming menace. It’s unsettling and beautiful and delightful. One of them where saying too much would spoil it a bit.

What did we learn?

• 🐶🔪💵🏃💃🎈🦉🚗751

Patriot (2015) (tv)

CIA operative gets a non-official cover job at a Miluake piping company in order to do CIA stuff. Clearly depressed and traumatised, we follow him as he does what’s expected, almost entirely alienated from reality and the people around him. At night he sings folk songs about his activities to process his emotions. It’s weird and dark and funny.

(caveat: I’ve only watched one of two seasons so far)

What did we learn?

• The CIA does bad stuff 😮

Welcome to Me (2014) (film)

A woman with borderline personality disorder wins the lottery and then pays for a TV talk show about herself. Will this alienate her further from those around her? Or will it help people understand her and she them? OMG I DON’T KNOW WATCH AND FIND OUT!!!!!!

It neither romanticises her ‘illness’ nor fetishises her struggle and feels (to me, as someone who doesn’t have it) true to how that disorder might feel.

What did we learn?

• Bananas are in their own container

Superman (2025) (film)

James Gunn sure knows how to make a comic book film. I’d not heard of him before but apparently “Superman” is a strong alien from a long-running series of comic books.

I enjoyed this film a lot. But more than that it was just really fucking refreshing to see a fun, actually-heroic, humanised Superman after the exhausting, miserable, loud, boring, violent, excessive, long, dark grey mess of the Snyder DC films.

It’s fun!

What did we learn?

• Everyone wants to fuck Jimmy Olsen

<3

I want to say thank you to the people with whom I enjoyed a lot of these on our discord server: Ghosty, Wing, Dani, Char, Temhr, Hamish, Anjune, Nado, ait and the ones I inevitably forgot. You made my year brighter, thank you <3

/images/trillian_emoticons.jpg

There was ‘pipeface’ (7 down, 2nd from right in the image above), summoned with :Y. It’s a picture of a person with a resolute frown smoking a pipe. I have absolutely no idea whatsoever what it was intended to convey and it doesn’t matter - we used it when we knew we were being a bit pompous (perhaps playfully, perhaps not) or to convey finality - a sense of … and I will brook no further argument. “It’s a shit game and I shan’t play it :Y”, “Monet is overrated :Y”, “A meal fit for a king :Y”. There’s no emoji that does that.

Then there were ‘hugleft’ and ‘hugright’, summoned with ({) and (}) (4 down and 3 & 4 in on the image). We used this when we were feeling sad or vulnerable or just in need of comfort. One would request/offer with ({) and others would complete with (}). And there was a sense of completion to it - it was bilateral, like a hug.

And ‘nod’, summoned with (nod) (9 down, 3 in). This one was animated and, because of its unblinking stare and smug, slow nod, it was usually used sarcastically.

There are so many good ones but the last one I’ll touch on is inlove, summoned with %) (9 down, 2 in (left of (nod))). Another animated one where the eyes would kinda drift around resulting in a delirious expression that really captured feeling love in a way that the lazy sterility of 🥰 and 😍 simply do not.

My friends and I continued using the textual form of these emoticons long after we could convince the platforms we were chatting on to use the pictures. I still sometimes end sentences with ‘:Y’.

Emoticons were great. Whichever emoticons were used in a particular community would gain meanings specific to that community. They had personality and a bit of humanity to them, which allowed them to gain meaning through interpretation and use. To be contextual and fluid while, in a particular context, specific. They were aesthetically rich and semantically vague enough to encourage reading in - they were descriptive rather than prescriptive.

And then there’s the bland dead-eyed coporate HR-clipart of emojis…

Bland

They’re bland for the exact same reasons that clipart is bland - by design. They’re cornflakes - designed to elicit no feelings whatsoever. They’re as devoid of imagination and humanity as the corporate culture that shat them wetly onto our screens. They make Vettriano look like Caravaggio. They were begotten without love. The propaganda of purgatory.

If you want to send someone a hug you’ve got 🤗, which looks like a sex predator coming in for a titty grab or 🫂, two ghouls embracing limply. Corporations don’t understand love or compassion or comradeship. So this is what we get, a hug is either sex predation or two empty mannequins in a flaccid grapple.

Here’s the Trillian hug emoticon for contrast:

Sure it has the advantage of being animated but, that aside, there’s a warmth and humanity to it. It feels right. Because it was made by a person who had experienced a hug ever, not a consortium of Californian vampires.

There’s too many of them

There are so fucking many of them. According to the unicode website there are either 1910, if you look at the full emoji list or 3790 if you look at emoji counts. Either way, it’s a fucking lot.

To put that into perspective, the constructed language Toki Pona, created by Sonja Lang has 120-137 words. It’s a minimalistic language by design but it supports full conversations. With, at most, 1/16th the number of symbols as emoji. Could you have a full conversation in emoji? Could you fuck as like.

The language Trigedasleng, created by David J. Peterson for the TV show The 100 has about 1700 words and I know for a fact supports full conversations (and fanfics and song translations and so on) because I have friends who do that.

And emojis aren’t even a natural language - they don’t need to be able to express all that can be said - they exist, as did the earliest ASCII smileys, to convey what doesn’t come across easily in text - mood, tone, posture and so on.

Their job is just to augment natural language - to add a bit of warmth or to let the other person know I’m being facetious or feeling sympathetic or irritated or bored or delirious with love.

And somehow we’ve ended up with about 2000 of them. Which is far too many to visually scan through, as you could with emoticons back in the day, so you have to search. Which brings me to…

What’s going on with the fucking names?

I want to send 😐 so I search for “straight mouth” cos, y’know, we humans call that a straight-mouthed expression. I eventually find it under “neutral expression”. Which, first off, it isn’t really, that would be a blank-eyed stare. And, secondly, yeah that’s absolutely how humans talk. Neutral expression. Just set all our transistors to zero and that’s the expression we humans have.

I want to send a nod, so I search for… that. But no, “head shaking vertically”. Y’know, like we all say. “Yeah I agreed with her so I shook my head vertically.” So normal. So human.

I want to send 💦, so I search for water? Nope. Splash? Nope. Drip?! Nope. Oh it’s sweat droplets. Of course. Because we all think in anime.

This isn’t the fault of whatever software I happen to be using to send the message, these names are baked into the standard.

The primary problem is having so many that I need to search rather than picking at a glance. The secondary problem is that these names are a mishmash of, in some cases, trying to describe what’s happening without assuming any social or cultural context - some cultures don’t nod in agreement so let’s call it a “vertical head shake” - and, in other cases, describing them in a very specific cultural context as with “sweat droplets”.

They really don’t know whether they want to be general and standard or specific.

The general and the specific

Emoticons worked best when they tended towards aesthetic richness and semantic looseness. By which I mean they had a ton of personality and were visually fun, such that they invited reading-in and repurposing, and they were not too tied down semantically - I have no idea what pipeface was supposed to mean, we imbued it with meaning ourselves.

This allowed them to… do their job. To add context, emotion and situationality. Not to try to do the job of natural language and convey straightforward meaning.

Emojis go the absolute other way - aesthetically sterile and semantically nailed down.

Trillian had a couple of emoticons for food. So if I wanted to express that I was really looking forward to my food I could say “I’m making cheese on toast (food)(drool)”

It didn’t matter what food it was. Food is a shared human experience, it didn’t need to be specific.

Similarly there was one flag emoticon. It was just a red flag. It could be used to express shared pride or comradeship like “I’m watching India win the cricket with Nish (flag)” or “We’re going on the protest later (flag)” or “Branston Pickle was invented in Staffordshire (flag)”

It didn’t matter what the flag was, it just represented shared experience and communality in a particular context.

Oh but I see emojis have 300-odd flags so we’re all divided up again, lovely. The dream of the internet.

And 130 food items. 30ish Japanese foods, due to emoji’s heritage, a bunch of fruit and veg and the rest are mostly… foods that Californian techbros have heard of.

This is the problem with specificity. We have 130 very specific foods but not a single specific food item from Africa or South Asia. And one from West Asia because Californian techbros have had falafel I guess.

And no North Staffordshire oatcakes, an absolute fucking travesty (flag)

We’re going to end up with 5000 food emojis and it’ll never have the one you actually want in the moment unless you eat nothing but sushi and texmex. What an improvement over just having a plate of food!

But at least we’ve got the 🔰 emoji. For all the times every day I want to say 🔰 and would have no way to say 🔰 without 🔰 being an emoji 🙅

What?

Emoticons, and textual smileys before them, were made with love, by and for communities. They gained life within the communities in which they were used. They were fun and human, rich and fluid, and brought joy to communication by helping express those things that text doesn’t well.

Their strength was their abundance of visual personality and semantic flexibility. They worked through shared experience and communality, gaining more meaning as they were used in a particular community over time.

Emojis are sterile, lifeless slop handed down by our corporate brahmins, devoid of even a drop of humanity. They’re specific in all the places they should be universal and vice versa. They’re aesthetically dull and nailed-down semantically to the point of uselessness. Like the PMC HR-speak of their creators, they constrain our expression rather than amplifying it.

Emojis are ugly. In a more profound sense than just being unpleasant to look at (which they also are). They say something ugly about us and how we see ourselves. Emoticons were poetry and emojis are a CV, a marketing email, a corporate mission statement. They’re a Verschlimmbesserung :Y

Anyway, prompted by your friend and mine, Chris Were, I’ve been giving xterm a go. And it’s good! I’m sticking with it!

There’s a simple pleasure in returning to the old standards that’ve been around since humankind first emerged from their caves and needed to emulate terminals. It’s like unearthing your grandmother’s old recipe book and finding that she really knew her shit, but there’s also recipes like Ham and Bananas Hollandaise so you just ignore those and blame the vallium addiction.

For me, the sticking point with xterm before was the lack of emojis. Not that that is an essential thing in a terminal emulator, but I use mutt for email and when my sisters send me emojis it’s nice to see them.

But it does emojis now! And even sixel (kinda)!

Sixel (kinda)!

One shocking realisation when using the terminal emulator xterm is that it emulates terminals. As in it emulates actual specific physical terminals that actually existed.

The default terminal it emulates is the VT420, which did not have sixel support. To get that, you need to drop down to an older terminal - the VT340 - which did have sixel support. You do this by launching xterm with xterm -ti 340 or setting XTerm*decTerminalID: 340 in ~/.Xresources.

/images/obligatory_fetch.png

A quick overview of xterm’s pros and cons:

Pros:

• It starts with ‘X’, the coolest letter
• It’s from 1984, the year we solved hunger
• It’s not GPU accelerated
• It doesn’t support Wayland
• It starts really fast - perceptually as fast as st, to me
• It’s the de facto standard terminal emulator. It works with everything. And you’ll never have to fuck around with terminfo files ever again
• It has a cool logo

Cons:

• It also has an uncool logo

Shut your fat fucking mouth and tell me how to configure it all nice like

Okayyy, fine. Gee willikers.

Xterm, like many old X things (and some newer ones), is configured through X Resources. You edit ~/.Xresources, then run xrdb -merge ~/.Xresources and the settings will take effect next time you pop an xterm open.

First let’s define our colours, that happens like this:

! special
*.foreground: #f0ebe3
*.background: #040404
*.cursorColor: #f0ebe3

! black
*.color0: #080809
*.color8: #535353
! red
*.color1: #ff0064
*.color9: #ff0064
(etc.)

Obviously you do all the other colours too, I’m just saving space.

I could be more specific and set XTerm*colour1: ... but then it would only be picked up by xterm. The way I’ve done it, it’ll be read by any terminal emulator which uses X Resources.

Then the font face and size

! xterm
XTerm*fastScroll: true
XTerm*faceName: IBM Plex Mono
XTerm*faceSize: 11

That’s self explanatory. The fastScroll setting sacrifices a bit of accuracy for throughput - a compromise most modern terminal emulators make - I recommend setting it.

Rather than allowing the free resizing of fonts, xterm has some predefined font sizes which you can choose between. You can set those like this:

! VT Font Menu: Unreadable
XTerm*faceSize1: 8
! VT font menu: Tiny
XTerm*faceSize2: 10
! VT font menu: Medium
XTerm*faceSize3: 14
! VT font menu: Large
XTerm*faceSize4: 16
! VT font menu: Huge
XTerm*faceSize5: 22

Now let’s turn off the blinking cursor (adjust to taste of course) and a coupla other convenience oozits.

XTerm*utf8: true
XTerm*cursorBlink: false
XTerm*scrollKey:true
XTerm*saveLines: 9000

I’m not entirely convinced utf8 does anything on my system but I leave it there for good luck. scrollKey: true makes the terminal scroll return to the bottom when you’re scrolled up and you hit a key. saveLines: is how many lines of history you can scroll back through.

XTerm*backarrowKey: false
XTerm*ttyModes: erase ^?

The above fixes the backspace key in certain programs. If you find your backspace key misbehaving, stick that in.

XTerm*scrollTtyOutput: false

That prevents the terminal from scrolling back down when you’re scrolled up and there’s new output.

XTerm*borderWidth: 0
XTerm*internalBorder: 33

borderWidth is an exterior border on the xterm window (and the menu windows - more on that later). internalBorder is … an internal border, between the window edge and the contents.

XTerm*termName: xterm-256color

Set that so that programs know which terminal they’re dealing with.

XTerm*selectToClipboard: false
XTerm*alternateScroll: true

selectToClipboard: false tells xterm to use the clipboard rather than the primary selection and alternateScroll allows mouse-scrolling in alternate windows (such as less).

And here’s how to do a few key bindings:

XTerm*vt100.translations: #override \
    Shift Ctrl <Key> C: copy-selection(CLIPBOARD) 
\
    Shift Ctrl <Key> V: insert-selection(CLIPBOARD) 
\
    Shift Ctrl <Key> R: set-reverse-video(toggle) 
\
    Ctrl <Key> plus:larger-vt-font() 
\
    Ctrl <Key> minus:smaller-vt-font() 
\
    Ctrl <Key> 0:set-vt-font(d)

With those applied, ctrl-shift-c and v will copy and paste text. ctrl-shift-r will toggle the foreground and background colours (fun!).

ctrl and +/- will increment/decrement through the font sizes and ctrl-0 will reset the font size to default.

But what about that menu thing you said something about or whatever

If you press ctrl and one of the three main mouse buttons, you’ll notice that xterm has weird menus! Where you can do insane stuff like save what you see in your terminal as HTML or SVG. Mental.

But those menus probably look like arse. That’s because they’re drawn with something called Athena, which does things in the old fashioned X way that they used in the Edwardian times: XFLD.

On a modern system (at least on mine) this stuff isn’t really used any more. There’s one built-in, fallback font specified in that way just so that such things can work at all. But it’s not ideal. If that’s the case for you, too, you’ll need to generate some definitions.

You’ll need mkfontscale, mkfontdir and xfontsel. On Arch that means installing xorg-mkfontscale (which includes both mkfontscale and mkfontdir) and xorg-xfontsel.

Locate the directory that contains the font you want to use. Or do as I did and just do it for all system installed fonts.

If you’re doing it in one directory, just go to the directory containing the fonts and run:

mkfontscale
mkfontdir
xset fp rehash

If, like me, you’re doing it in a directory with subdirectories which contain the actual fonts, in my case /usr/share/fonts/, then cd to that directory, then (probably as root depending on location), run:

for dir in * ; do if [  -d  "$dir"  ]; then cd "$dir";xset +fp "$PWD" ;mkfontscale; mkfontdir;cd .. ;fi; done && xset fp rehash

Either way you do it, that will generate the necessary descriptions.

Now you can run xfontsel to choose the font.

/images/xfontsel.png

Click on -fndry and -fmly to narrow it down to the typeface you want, then choose the variant with -wght and slant. Then choose a -pxlsz if you’re using a bitmap font or a -ptSz if you’re using a vector font (TTF or OTF).

You can then click on the select button, which will put the font definition string on your primary selection. You can middle click to paste it somewhere.

/images/xfontsel_done.png

You can then add these lines to ~/.Xresources to configure the menus:

XTerm*SimpleMenu*font: -*-ibm plex mono-medium-r-normal-*-*-100-*-*-*-*-*-*
XTerm*SimpleMenu*background: #333333

Lastly, set the emulation to VT340 if you want sixel support. If you notice any jank, just delete this and go back to the defaul.

XTerm*decTerminalID: 340

(I changed the font size from 120 to 100).

And that’s it. Here’s everything together (excluding colours):

! xterm
XTerm*decTerminalID: 340
XTerm*fastScroll: true
XTerm*faceName: IBM Plex Mono
XTerm*faceSize: 11
XTerm*SimpleMenu*font: -*-ibm plex mono-medium-r-normal-*-*-100-*-*-*-*-*-*
XTerm*SimpleMenu*background: #333333
! VT Font Menu: Unreadable
XTerm*faceSize1: 8
! VT font menu: Tiny
XTerm*faceSize2: 10
! VT font menu: Medium
XTerm*faceSize3: 14
! VT font menu: Large
XTerm*faceSize4: 16
! VT font menu: Huge
XTerm*faceSize5: 22
XTerm*utf8: true
XTerm*cursorBlink: false
XTerm*scrollKey:true
XTerm*saveLines: 9000
XTerm*backarrowKey: false
XTerm*ttyModes: erase ^?
XTerm*scrollTtyOutput: false
XTerm*borderWidth: 0
XTerm*internalBorder: 33
XTerm*termName: xterm-256color
XTerm*selectToClipboard: false
XTerm*alternateScroll: true
XTerm*vt100.translations: #override \
    Shift Ctrl <Key> C: copy-selection(CLIPBOARD) 
\
    Shift Ctrl <Key> V: insert-selection(CLIPBOARD) 
\
    Shift Ctrl <Key> R: set-reverse-video(toggle) 
\
    Ctrl <Key> plus:larger-vt-font() 
\
    Ctrl <Key> minus:smaller-vt-font() 
\
    Ctrl <Key> 0:set-vt-font(d)

And you can find my full ~/.Xresources file here if you’re a dirty snoop.

When I think of the web, I think of a network of weird and interesting sites made by weird and interesting human beings. This is not what the web is now - it’s a handful of silos that hoover up, brand and monetise everything else.

Small sites still exist, of course. But they’re drowned out by the cacophony of capitalist slop. The small web movement is cool, and there are some lovely small websites, but it increasingly feels like trying to hold a book club in a busy shopping centre.

So I’ll use the ‘web apps’, to the extent that I do, but I’ll find the humans I used to look for on the web over on Gemini and Gopher. I’d love to bump into you over there!

Dynamic linking

This is the ‘norm’ on Linux. This is where (ideally) there’s one copy of ffmpeg installed and any program that wants to make use of ffmpeg (i.e. anything that wants to play or encode video and audio) uses that same version.

The big upside of this way of doing things is that it’s efficient. One copy of each library - what’s the point of having shared libraries if they’re not shared?

The (considerable) downside is that managing this - keeping track of the web of dependencies - is very complex, and each distro must do this itself. That’s a lot of duplicated effort. Dynamic linking necessitates complex, and sometimes fragile, package management systems.

A graph of dependencies on my fairly sparse (~650 packages) system, generated with pacgraph:

/images/pacgraph.jpg

An upside of having that complex package management system, though, is that we can update everything on our system all in one go, and that process is (ideally) very efficient since nothing is duplicated.

But…

What happens if two programs need different versions of ffmpeg?

Well, there are two basic approaches to this: accommodate that or don’t.

Arch, for example, takes the general approach of having only one version (the latest) of each library. If the latest version of mpv doesn’t work with the latest version of ffmpeg then this is a bug, and must be fixed.

The advantage of Arch’s approach is simplicity from a packaging point of view. Drawbacks include the inability to, within this system, use old software, and a lack of stability (meaning “things keep changing” not “things keep crashing”).

Debian takes the other approach - allowing different versions of libraries to be concurrently installed. This allows for the use of old software, atomic upgrades (i.e. updating/installing one application without updating the whole system) and allows for stability. But it compounds the complexity of package management.

From the point of view of a user, dynamic linking is kinda ideal. It makes the most efficient use of storage, memory and bandwidth and allows for the easy installation and maintenance of all software from the OS itself through to applications.

For the developer and maintainer, though, it’s potentially a nightmare. It means that a package has to be created for every piece of software on every distro. Not so bad for established software - the process will often be largely automated and will be the responsibility of each distro’s maintainer for that package. But for a developer making new or niche software which is not yet in repos, it’s quite a burden. To distribute their software for Linux they’d have to create and maintain a package for every distro (or at least a big few) - a process with which they’re likely to be entirely unfamiliar and which will differ from distro to distro. They’ll also be distributing that package outside of the package manager’s repos (PPAs and Arch’s AUR aside), which is far from ideal.

Summary

• + Great for users (so long as everything’s in the repos)
• + Efficient use of system resources
• - Requires complex package management infrastructure
• - Unfun for developers

Bundling

This is where you bundle the needed libraries with the software. The libraries don’t get installed on the system, they just sit there in the application’s directory. Which seems like a good idea until you realise that, unless you include everything up-to-but-not-including the kernel, those libraries are still making use of system libraries. And at some point, that’ll stop working (as system libraries get updated).

On Linux I’ve only ever seen this approach with proprietary software. It’s how GOG games used to be distributed, for example. I usually take it as a signal that the distributors of the software have no intention whatsoever of maintaining the thing, which held true for GOG.

Appimages are sort of containerised bundles. They’re convenient, in that you can just download a single file and run it without having to worry about dependencies and so on, but they’re maximally inefficient, fiddly to maintain, and don’t confer any of the broader benefits of ‘proper’ containerisation.

I do use a couple of Appimages - one is Libreoffice, which is a piece of software I resent having to have installed for the rare times someone sends me a .docx or .xlsx and expects me to see it how they’re seeing it. I don’t care if Libreoffice is up-to-date, I don’t want its dependencies cluttering up my package management and I don’t enjoy or like it as software. I want to forget it’s there as far as I possibly can and Appimages suit that.

But really, bundling is the worst of all worlds.

Summary

• + Easy for developers
• + Convenient…
• - … until they stop working
• - Bad in every other way

Static linking

This is some special magic whereby the bits of a library that a program uses are included in the program at compile-time. If the program makes use of ffmpeg then the bits of ffmpeg that are used are pulled out and included with the application (in an object file, I believe), meaning that a system running the software doesn’t even need to have ffmpeg installed.

(ffmpeg is probably a terrible example in this case but this is just illustrative)

This approach involves some redundancy - you may have tweaked your system-wide ffmpeg and want to use that - but simplifies packaging and reduces dependencies, making life easier for developers.

This is like the cleverer version of bundling. It shares, but reduces the impact of, bundling’s drawbacks while retaining its advantages.

Summary

• = A balance between efficiency and ease of development
• - Less efficient and flexible than dynamic linking for users
• + Less complex in terms of package management

Flatpaks (containerisation)

Remember where, under ‘Bundling’, I said:

unless you include everything up-to-but-not-including the kernel

Well, this is kinda that.

A container, in this context, is like another copy of a Linux operating system running on your current OS’s kernel. This may sound like a virtual machine, but it’s not really. A virtual machine emulates a CPU and then runs an entire Linux OS on that emulated CPU. A container is just a bunch of software that believes it’s a Linux OS, running on your current kernel and hardware. VMs involve much more overhead than containers.

Here’s a hopefully illustrative example. I’m using distrobox to run Debian in a container:

/images/distrobox.jpg

As you can see from the output, they (optionally) share the host’s home directory but otherwise Debian’s filesystem is its own - it is fully Debian. Both distros see the same hardware and kernel but they are otherwise separate.

That’s roughly how Flatpaks work. Flatpak applications run within a containerised copy of Linux, running on your ‘host’ OS’s kernel and sharing its hardware. This obviously involves a significant amount of duplication but, within Flatpak itself, duplication is minimised through the use of shared ‘runtimes’ which applications make use of.

This approach is, effectively, a universal package system for all Linux distros, which is great for developers.

It also provides some ‘sandboxing’ - separation between applications and the base system - you can restrict which parts of the filesystem and what devices a containerised application has access to.

Summary

• - Inefficient compared to dynamic linking…
• + … but duplication ideally happens only once
• + A single package manager for all distros is good for developers

Going further (immutability)

So if you take that idea of isolating applications from the base system to its natural conclusion you could completely isolate the base system from applications. Make the base system essentially ‘read-only’ - applications cannot alter it in any way.

This is immutability, and there are a few ways to get there. One way is to make all applications containers, this is the path Ubuntu is going down with its Snaps. This would work with Flatpaks, too.

NixOS takes a different approach. On NixOS, every package is installed to its own directory which means that multiple versions of dependencies can exist at the same time. A program will use the exact dependencies it is built against. This isn’t containerisation as such but shares some of the benefits, while also retaining the benefits of dynamic linking.

Everything in NixOS - which packages are installed and also runtime configurations - is (or at least can be) configured in one place. The system can easily be ‘rolled back’ to a previous state and that configuration can easily be copied to another machine to produce the exact same setup.

Immutability is an attractive idea - you can have a very stable base system and run whatever bleeding edge applications you like without ever risking the integrity of that base system.

Summary (of immutability in general)

• + Stable base system and applications as cutting edge as you like
• + Depending on the method used can facilitate reproducibility
• - Likely to involve some redundancy, depending on method
• + Probably the future

Conclusion

I used to be very dubious of containerised applications. The efficiency of dynamic linking seems so intrinsically linuxy and, while package management was a hard problem to solve, it seems to work great now from a user’s perspective.

Flatpaks seemed to be a move to appease developers of proprietary software which is something I have no interest in at all.

But then I realised I could install Krita without pulling in half of KDE. And install Steam and play games without having 32bit libraries - which were only used by Steam and games - installed in my base system. All that stuff is still there, of course, but it’s tucked away where I don’t have to look at it, and it doesn’t get updated every time I update my base system.

Valve have gone with an immutable base on the Steam Deck for good reason, immutability is very appealing. The advantages of running Debian stable plus the advantages of, say, Arch, with some additional advantages on top. Of course, if immutability is implemented through containers then it carries with it the disadvantages of containers in general, and if it’s implemented in the NixOSy way then you still have complex package management. But the upsides seem well worth it to me and I expect distros with an immutable base to become the norm over the next decade or so.

~/.ssh/config lets you make what I think of as ssh aliases. You can give connections short names and specify various connection settings ‒ pretty much anything you can pass to ssh’s CLI can be configured here.

Here’s a simple example:

Host nas
    Hostname 192.168.1.10

Host laptop
    Hostname 192.168.1.11
    User laptop-me

Host someserver
    Hostname 203.0.113.1
    User seriousthings
    Port 10100
    PubkeyAuthentication yes
    Identityfile ~/.ssh/id_rsa_seriousthings

Host *
    PubkeyAuthentication no

I am then able to do, for example, simply: ssh nas

These settings apply from top to bottom, cumulatively. So you want to structure this file with specific rules above general rules, otherwise the general rules will override the specific, which is not what you want.

One nice benefit is that you’ll get autocompletion of hosts defined in ~/.ssh/config when using ssh under bash or zsh (at least).

~/.ssh/config can also be used to shore up some of the leaky parts of sshing, as described here ‒ the whole page, and other articles in the series (linked at the top) are worth a read if you use ssh a decent amount.

ddcutil primarily uses DDC/CI (Display Data Channel Command Interface) to communicate with monitors implementing MCCS (Monitor Control Command Set) over I2C.

Whatever that means.

Obviously ddcutil will only work if the monitor supports that stuff. Reading around suggests that most but not all do.

ddcutil will not work on laptops as they use a different interface.

Its usefulness for me is that I have a Nintendo Switch plugged into my main monitor as well as my PC. When I want to play on my Switch, rather than leaning over my desk and using the super fiddly buttons on the front of my monitor, I can just hit a key combo to switch between the DisplayPort input my PC uses and the HDMI used by my Switch.

The same approach could be applied to VFIO passthrough setups or just, as mentioned above, for adjusting brightness and so on.

Preparation

To use ddcutil the i2c-dev module must be loaded. On some distros it’s built into the kernel, if it’s not it’ll need to be explicitly loaded.

To check whether i2c-dev is built in, run:

grep i2c-dev.ko  /lib/modules/`uname -r`/modules.builtin

If you get output then you’re all good. If not then you need to explicitly load the module by adding the line i2c_dev to /etc/modules or create a file containing that line in /etc/modules-load.d/.

In my case, on Arch, the module was not included in the kernel so I created the file /etc/modules-load.d/i2c-dev.conf containing the single line:

i2c_dev

That’ll only take effect next time you reboot so for now you can load the module directly with:

sudo modprobe i2c_dev

Using ddcutil

Once the i2c_dev module is loaded we can do:

sudo ddcutil detect

To detect monitors. The output in my case is:

Display 1
   I2C bus:             /dev/i2c-5
   EDID synopsis:
      Mfg id:           DEL
      Model:            DELL U2715H
      Serial number:    GH85D67S05JS
      Manufacture year: 2016
      EDID version:     1.4
   VCP version:         2.1

If you’ve got multiple monitors, pay attention to that Display number – you’ll need to use that with subsequent commands. So if you want to operate on display 2, for example, wherever I use ddcutil, you’ll want to use ddcutil -d 2.

Once you’ve settled on a display, run:

sudo ddcutil capabilities

Which will output a load of stuff that ddcutil can mess with on the monitor.

The one I’m interested in is Feature 60 (Input Source) (I believe feature codes are common across devices but don’t take my word for that).

   Feature: 60 (Input Source)
      Values:
         0f: DisplayPort-1
         10: DisplayPort-2
         11: HDMI-1
         12: HDMI-2

There we see feature code 60 with its possible values and what they mean.

We can get the current value of any particular feature by using ddcutil getvcp. Feature codes are hexidecimal and need to be prepended with 0x when used in commands. So to get the current input source we can do:

sudo ddcutil getvcp 0x60

Which outputs:

VCP code 0x60 (Input Source                  ): DisplayPort-2 (sl=0x10)

We can change settings with ddcutil setvcp. So, if I want to switch to HDMI 2, which has the code 12 in the output up above, we can do:

sudo ddcutil setvcp 0x60 0x12

And my monitor will switch over to HDMI input. It takes a couple of seconds but it works. Magic.

So to make this super-useful to me I wrote a little bash script which toggles between DisplayPort 2 (my PC) and HDMI 2 (my Switch) and bound it to a key combo:

#!/usr/bin/env bash
notify-send "Switching..."
if sudo ddcutil getvcp 0x60 | grep "DisplayPort" > /dev/null 2>&1;then
    sudo ddcutil setvcp 0x60 0x12
else
    sudo ddcutil setvcp 0x60 0x10
fi

As you can see, ddcutil requires root permissions to do its thing. You can handle this in whatever way you like in any scripts you make – I just use sudo because I am not clever like you are.

But what about poor old neglected top? It may look like a bag of trowels out-of-the-box, but with a little care and attention it can look pretty cool, too. Here’s mine:

/images/top_top.png

And it does it without needing a huge scripting language to run; its only real dependency is ncurses and you can pretty much guarantee it’ll be preinstalled on any machine you use, regardless of the flavour of Unix it’s running.

And being a proper Unixy thing, with top you can do things like:

top | grep firefox

Can those fancy monitors do that? Can they fuck as like.

But how can I make my top look fly like yours?

Well, I’m glad you asked.

Top’s documentation is excellent – both the manpage and the in-application help which is accessed by pressing h. If you enjoy figuring stuff out yourself then the latter is all you really need – you can close this right now, press h and get customising.

At any time while customising your top you can press W to save your settings.

Now let’s get some nice CPU bars. Press 1 to expand the CPU info thing at the top to show all cores. The default is to show text-based stats so press t to get pretty bars. You can press t a few more times if you’d like to see your other options.

You can do the same with the memory usage summary by pressing m – cycle through the options and use what you prefer. Personally, for memory, I prefer the full stats.

Press 0 to omit numerical fields with zeroed values from the process list if you think that looks nicer/clearer as I do. Then J to justify numbers.

If you only want to show tasks for your user, type u and then enter your username.

Now press z to get some colour and x to highlight the sorted column with bold.

Some optional stuff:

• Press c to toggle between just task names and full paths
• Press e and E to cycle through scales of memory units – i.e. bytes, KiB, MiB etc. – in the task list and memory area respectively.
• Press V to view processes as a tree

Okay, so that’s a good start. All we’ve done so far is press 1t0Jzx and now we have this:

/images/top_1t0Jzx.png

Press W to save your hard work.

Windows‽

Top’s big secret is that it comes with four windows defined (that’s what it calls them). By default you’re in Single Window Mode – Press A to switch to Multiple Window Mode.

Unfortunately these new windows are ugly. We can switch between windows by pressing a and w, so let’s pretty them up by pressing a1t0Jzx three times.

Now we have four windows each with the same settings, like so:

/images/top_a1t0Jzx_x_3.png

You can use as many of these four windows as you like, each with its own fields and settings. I like to have two – one ordered by CPU usage and the other by memory. Adjust to taste, obviously.

First of all let’s hide the bottom two windows. Move to them using a and w and press - to hide them. you can tell what window is currently selected by looking at the number in the very top left (if you don’t see that, press l to being the summary back).

You can also switch windows by pressing g then the number of the window you want to select.

Press g1 to select the first window then G and name this window as you please. Now press f.

/images/top_fields.png

This screen allows you to customise which fields are displayed in the currently selected window. Use cursor keys (or Alt + j and k) to move up and down this list, d to toggle whether a field is displayed and s to choose the field by which the window is sorted.

To move fields around, press right cursor (or Alt + l) to select an item for move, then just move it up and down the list as you like. Press left cursor (or Alt + h) or Enter to complete the move.

Press q when you’re done.

Now press Z so we can make the colours pretty.

/images/top_colours.png

This window explains itself very well so take some time to read it. At the top is a preview of how the selected window will look. Press the keys 0 - 7 to change the colour of the currently selected element. Select an element by pressing S, M, H and T for Summary Data, Message Prompts, Column Heads and Task Information respectively.

Colour all the things until they sparkle then press Enter to commit your changes and return to top. Be careful here, unlike on the previous screen pressing q will abort your changes.

Repeat these steps until the windows you want to use have all the fields and colours you want.

And you’re done!

Don’t forget to press W to save your customisations!

Now my top looks dope but how do I actually use it?

Top can do a lot of clever stuff but let’s be honest, as desktop users all we really want a process monitor for is generally keeping an eye on things and killing anything that misbehaves. If you’re a sysadmin you no doubt know what you’re doing much better than I do.

So I’ll just explain how to filter your process list and kill anything that’s being naughty.

First of all, select the window that best represents what you’re interested in (i.e. CPU usage, RAM usage etc.) then press A to make things clearer.

To filter this list press o (or O if you wish your filter to be case-sensitive) then type, for example:

• COMMAND=firefox to show processes whose COMMAND field contains firefox
• !COMMAND=firefox to show processes which don’t contain firefox
• %CPU>3.0 to filter to processes whose %CPU field is greater than 3.0

For more info on filters do a man top.

Okay, let’s clear those filters by pressing =.

To kill a task you simply press k then type the PID of the process you wish to kill. This will default to the process at the top of the current list, which is usually what you want – i.e. if you wanted to kill the process with the highest CPU use, you’d choose your CPU usage window and then press k. If that’s not the case then filtering, as described above, can make it easier to spot the PID of the process you wish to kill.

After choosing a PID you’ll be asked which signal to send. The default is SIGTERM (signal number 15) which tells the process to exit in a seemly manner. If you want to send the “fuck you, close” SIGKILL instead, bad practise as it may be, enter 9.

And that’s it. Top may not be the prettiest of all the task managers but it’s extremely powerful and customisable and, to my mind, just looks and feels more unixy and thus, obviously, cooler…

https://www.youtube.com/embed/Bmz67ErIRa4