The Voidcruiser

Distortions

Thu, 26 Sep 2024 17:14:09 +0200

Festering Ideas

Epilepsy warning

I’ve always liked glitchy looking images and videos. I just never bothered creating my own. That is until I came across the frei0r library by the Dyne project. Here I found the glitch0r effect and messed around with it for a bit in Kdenlive. However, as a terminal terminal user, using a graphical interface didn’t feel right. So I figured out how to use the frei0r effects with ffmpeg.¹ Now I could script the butchering of a bunch of files at once!

Among the effects in frei0r, I also found scanline0r and a bunch of other effect, but wasn’t quite happy with the fact that the scanlines in question seem to be stuck at one resolution. Some time later (a few years), I heard someone complain about professional footage being interlaced and it looking like shit as a result. Upon closer inspection it had been the kind of ugly mess I’d been hoping to create with the scanline0r filter. So I got around to figure out how to interlace video using ffmpeg and butchered some videos further.

First Manifestations

Here’s a demonstration of what I managed to do so far using Big Buck Bunny as an example:

Original clip from Big Buck Bunny

This snippet was chopped up using ffmpeg using the following command:

ffmpeg -ss 00:01:17 -i big_buck_bunny_720p_h264.mov -to 00:00:11.75 rabbit_original.mp4

Epilepsy warning

My butchered version

ffmpeg -ss 00:01:17 -i big_buck_bunny_720p_h264.mov -vf 'frei0r=filter_name=glitch0r:filter_params=0.05|0.8|.02|1,rgbashift=rh=6:bh=-4,interlace=scan=tff:lowpass=complex,format=yuva420p' -to 00:00:11.75 rabbit_mangled.mp4

The full original video can be found on the Big Buck Bunny website

Magick

In the mean time, I had been messing around with imagemagick as well. Using it to create pictures of words of phrases when I felt like it. Usually I would use something like the following to that end:

magick -font $(magick -list font | grep Font: | awk '{print $2}' | fzf) -pointsize 288 -fill white -stroke black -strokewidth 5 -background transparent label:"*Insert text here*" example.png

The font used is Iosevka

Black Magick

So the other day, I thought it would be interesting to see if I could make some text using imagemagick and then feed it to ffmpeg to create a gif with an interesting glitch effect.

Initial text

Some text made with imagemagick because its the easiest way I know to create a simple image with text.

magick -font Iosevka -pointsize 300 -fill cyan -background transparent label:"Glitch" glitch.png

Note: The pointsize here is relevant as ffmpeg will complain if the image has a pixel count not divisible by 2. 300 works with Iosevka, if it doesn’t work with your font of choice, try a few sizes until you find one that does.

With glitch0r

ffmpeg -loop 1 -i glitch.png -vf 'frei0r=filter_name=glitch0r:filter_params=0.05|0.8|.02|1' -t 10 glitch.gif

Mangled results with imagemagick

Initial results looked quite interesting. Then I thought it’d be funny to convert this gif to an apng – animated png. This resulted in the gif being butchered in a really interesting way due to something in imagemagick being broken; when converting the gif to an apng using ffmpeg, it will come out on the other end in a state you’d expect.

Epilepsy warning

magick glitch.gif APNG:glitch_animated.png

Note: You have to supply the fileformat in prefix form as apng isn’t the standard format for the ‘png’ file extension.

After creating the apng I decided to convert it back to a gif in order to save some space as the apng was 11M.

magick APNG:glitch_animated.png glitch_butchered.gif

I experimented a bit with both ffmpeg and imagemagick to see what the best results would be. ffmpeg is significantly faster with the default settings but has a slightly large filesize.

$ ls -lh glitch_*
-rw------- 1 yog-sothoth users  11M Sep 26 18:57 glitch_animated.png
-rw-r--r-- 1 yog-sothoth users 5,1M Sep 27 09:48 glitch_ffmpeg.gif
-rw-r--r-- 1 yog-sothoth users 4,2M Sep 27 09:49 glitch_magick.gif

Note: No, I have no idea why the apng has a umask of 077. Imagemagick just spat it out like that.

Conclusion

I hadn’t seen anyone butcher visuals quite like this before, so I thought I’d write a post about it with the idea that someone else might find it interesting.

So, go out there and butcher some visuals!

For many of the frei0r effects I used Kdenlive to figure out their parameters. And for a list of available filters, I checked the ffmpeg-filters(1) manpage and looked for frei0r. Under the filter_name section, there are a few paths listed where ffmpeg checks for frei0r filters. ↩︎

Config Snippets

Tue, 09 Apr 2024 18:38:46 +0200

Mess

First I’m going to address an elephant in the room:

Why aren’t you publishing your dotfiles?

They’re too much of a mess with a bunch personal data entwined in the commit history that I don’t feel comfortable publicly throwing onto the internet.

Nix snippets

It’s no secret that I’ve picked up NixOS a few years ago. To that end, there are a few things that I don’t think I’ve seen other people do that I would like to share here.

`home-manager` color scheme

Some time ago, I came across the nix-colors project and came to the conclusion that it didn’t fit my needs. As a result, I put/hacked a function together that extracts the color schemes from pkgs.kitty-themes. I won’t go into the integration details in my personal config as it’s not exactly something I would call ergonomic. However, this is the function I came up with:

Expand to see a rather lengthy nix expression

{ lib, config, pkgs, ... }:
arg:
with lib;
let cfg = config.colorscheme;

    getKittyTheme = with builtins; (theme:
        let matching = filter (x: x.name == theme)
            (fromJSON
              (readFile
                "${pkgs.kitty-themes}/share/kitty-themes/themes.json"));

         in throwIf (length matching == 0)
            "kitty-themes does not contain a theme named ${theme}"
            "${pkgs.kitty-themes}/share/kitty-themes/${(head matching).file}");

    unwrapKittyTheme = with pkgs; path: let
      theme = runCommand "theme.toml" { nativebuildinputs = [ coreutils ]; } ''
          cat '${path}' | sed -E '/^#|^$/d;s/\s+(.*)/ = "\1"/g' > $out
          '';
    in (builtins.fromTOML (builtins.readFile theme));

    defaultTheme = {
      selection_foreground = "";
      selection_background = "";
      foreground = "";
      background = "";
      color0 = "";
      color1 = "";
      color2 = "";
      color3 = "";
      color4 = "";
      color5 = "";
      color6 = "";
      color7 = "";
      color8 = "";
      color9 = "";
      color10 = "";
      color11 = "";
      color12 = "";
      color13 = "";
      color14 = "";
      color15 = "";
      cursor = "";
      cursor_text_color = "";
      url_color = "";
    };

in defaultTheme // unwrapKittyTheme (getKittyTheme arg)

This function takes a name and matches that against the contents of pkgs.kitty-themes. If it fails to find something, it throws an error; If does find something, it returns that file, converts that to something approach TOML syntax, which is then parsed using builtins.fromTOML and merged with a minimum-viable-colorscheme, ensuring all colors are at the least declared as an empty string; I ran into issues here when using this output in combination with Qutebrowser when referring to colors that didn’t exist in certain colorschemes.

Qutebrowser

I manage my Qutebrowser config using the home-manager module (obviously). In my Qutebrowser config, I have JavaScript disabled by default and use a list of exception for trusted sites. When I first tried to set this up, I bumped into the obvious problem that Nix doesn’t allow you to bind multiple values to a single name. Luckily, the Qutebrowser module has an extraConfig option which takes a string. At first I had a bunch of lines for those exceptions:

config.set('content.javascript.enabled', True, 'https://hoogle.haskell.org/*')
config.set('content.javascript.enabled', True, 'https://search.nixos.org/*')
config.set('content.javascript.enabled', True, 'https://nix.dev/*')
config.set('content.javascript.enabled', True, 'https://voidcruiser.nl/searx/*')

However, I quickly got sick of the inherent inefficiency and illegibility of this approach, so I wrote a few little functions:

...
programs.qutebrowser.extraConfig = let
  enableJS = url: "config.set('content.javascript.enabled', True, '${url}')";
  javaScriptExceptions = [
    "https://hoogle.haskell.org/*"
    "https://search.nixos.org/*"
    "https://nix.dev/*"
    "https://voidcruiser.nl/searx/*"
  ];
  in ''
    ${with builtins; concatStringSep "\n" (map enableJS javaScriptExceptions)}

    # things I haven't managed to abstract properly yet
  '';
...

This takes the contents supplied in javaScriptExceptions and generates a viable config line based on each item by mapping over it with the enableJS function. Since the Qutebrowser config syntax can’t read the nix list syntax, the items of the resulting list and than concatenated using \n or a newline character.

XMonad

My XMonad configuration has a bunch of weird shit in it, some of which I’m proud of, some of which still has bugs that I keep telling myself I will get to At Some Point™. Here are some of the nicer bits.

Volume control using scroll wheel

I have bound Super + scroll {up,down} bound to {increase,decrease} volume respectively.

...
    , ((modMask, button4), \_ -> safeSpawn "pulsemixer" ["--change-volume","+1"])
    , ((modMask, button5), \_ -> safeSpawn "pulsemixer" ["--change-volume","-1"])
    , ((modMask .|. shiftMask, button4), \_ -> safeSpawn "pulsemixer" ["--change-volume","+5"])
    , ((modMask .|. shiftMask, button5), \_ -> safeSpawn "pulsemixer" ["--change-volume","-5"])
...

The hard part here was coming to the realisation that using a lambda that discards its argument was the best way to handle interactions while satisfying the type signature.

Other than that, these functions are quite straightforward. button4 is ‘scroll up’ while button5 is ‘scroll down’. I don’t recall where I found this, but it was somewhere in the documentation. As a result, when XMonad registers a combination of modMask and either of the scroll directions, it uses pulsemixer to increase or decrease the volume.

Kitty wrappers

I use the Kitty terminal. Kitty has a huge feature list, of which I feel like I use about 20% at most. One of these features is the ability to override config options using the -o parameter. This allows you to set a different font(size) or colorscheme or what have you.

I wanted to be able to start a BQN repl with the BQN386 font right from my window manager. So I wrote a few functions that take various arguments and supply them to Kitty without excessive syntax.

The simplest one of these is kittyWithOverrides. It can only take a list of -o parameters.

kittyWithOverrides :: [String] -> X ()
kittyWithOverrides = spawn . ("kitty " ++) . (unwords . map ("-o " ++))

Here is how I use this function to create a BQN repl window function:

largeTextBQN shell = [ "font_size=17"
                     , "font_family='BQN386 Unicode'"
                     , "shell='" ++ shell ++ "'"
                     ]

bqn = kittyWithOverrides $ largeTextBQN "bqn"

Note: I use a largeTextBQN function rather than a where binding, because I use the same settings for a few other repls as well.

This string will evaluate to the following at compile time:

kitty -o font_size=17 -o font_family='BQN386 Unicode' -o shell='/nix/store/6xwwmv4ljbfckkyklh512zxy6l9s0wv4-cbqn-standalone-0.4.0/bin/bqn'

…which will then be fed to spawn, thereby executing it. If I were to spend more time on it, I could figure out a way to do this properly using safeSpawn or one of its variants, but as it stands, I’m too lazy to do so.

For a more general interface I wrote a kittyWithParams function:

kittyWithParams :: [(String,String)] -> X ()
kittyWithParams = spawn . ("kitty " ++) . unwords . map unwrapParams
    where unwrapParams (flag,parameter) = case last flag of
                                            '=' -> flag ++ parameter
                                            _ -> flag ++ " " ++ parameter

Comparatively, it is rather messy. Still, the basic functionality is there and I’m quite happy with how it works.

Emergent Game Mechanics

Mon, 25 Sep 2023 02:36:11 +0200

Preamble

I usually talk about whatever hobby project I’ve been hacking together when the inspiration to write strikes. In a sense this is a similar ramble, just on a wildly different topic, namely video game design.

The Meat and Potatoes

For some time now I’ve been attempting to wrap my head around why I find games like Doom Eternal to be boring, while games like Ultrakill and Quake are some of my favourites of all time. And I think I’ve found the answer.

Doom Eternal has location based damage and various enemy weak spots. For instance, shooting the Mancubus’ arm cannons causes them to be disabled, making the Mancubus significantly more manageable. Likewise, shooting a grenade at a Cacodemon causes it swallow the grenade and be stunned for an easy Glory Kill. The Arachnotron has a turret that can be shot and disabled; the Makyr Drones can be shot in the head as quick ammo piñatas; the shields on the dudes carrying them can be easily disabled using the Plasma Rifle, causing a shock wave… so on and so forth.

Initially, I found these to be really neat ideas. However, it rather quickly became boring when I found out shooting the weak spots is really the only viable way to get rid of enemies, especially on higher difficulties. Sure, Doom Eternal allows you to be very creative in how you shoot those weak spots, but the moment you stop bothering with them, the difficulty curve starts to resemble something closer to a vertical line than an actual curve. The end result is that the combat feels pre-baked and static if you want to be remotely efficient.

Ultrakill does this right. It has – as far as I’m aware – two ways the trajectory of projectiles can be influenced. One being by punching a projectile as it is about to hit you. The other is with a shock wave, often caused by an explosion. Shock waves can be caused using the Knuckleduster (heavy melee attack), the Core Eject (shotgun altfire that shoots a grenade), the rocket launcher, parrying your own shotgun blast as it exists the barrel and several that I can’t think of right now. This is the only rule regarding projectiles that is set in stone. Because of this simplicity and how many enemies have projectile attacks, you can get very creative in how you kill them, while keeping all approaches equally viable at any given moment. When an enemy has just shot a projectile at you, you can chose to dodge it, answer it with a shotgun blast; punch it back to the culprit using a light melee attack; switch to heavy melee and shoot it back using a shock wave; overcharge the pump action shotgun, dodge out of its explosion damage using the I-frames received when dodging, while using said same explosion to send the projectile back to the unsuspecting enemy; use those I-frames from the dodge to go through the projectile and punch the enemy in the face retrieving some health in the process, etc, etc.

All of these are viable stratagies depending on how much health you still have and how many other enemies there are. Getting out of the way of overcharge explosion damage by dodging is no small feat, but might save you from more damage if you’re surrounded by a lot of high level enemies. Punching a single enemy isn’t something you’ll want to do when still surrounded as it means doing less damage in that moment and only damaging a single enemy. I could go on and on, describing how and when one might chose any given strategy, but I’ll try to stop here.

The result is an incredibly dynamic combat system that allows for endless creativity in dealing with any given scenario. If Ultrakill’s design philosophy were closer to that of Doom Eternal, there would be a dedicated “redirect projectile” button/weapon. It wouldn’t serve much of a purpose outside of deflecting the occasional projectile. On top of that, each enemy attack would have one and only one viable way to answer it.

For me an encounter in Doom Eternal would go something like the following:

Mancubus, take out its cannons using machine gun altfire; Arachnotron, ditto; Cacodemon, switch to shotgun, shoot grenade using altfire, Glory Kill; “oh hey, shield dudes”, switch to Plasma Rifle and pepper them a bit…

There is (usually) one “proper” strategy to deal with each enemy. As a result, instead of improvising throughout the entire fight, I’m focussing on what hoops to jump through and in what order. And I guess I don’t like being treated as a circus lion. In Ultrakill, I just do what comes natural in any given situation without feeling like I’m being forced down a rather face-paced-yet-impressively-boring path.

Doom Eternal’s movement is even more strict. There is a double jump, double dash and later on a grapple hook. Sure, there are some interesting things you can do here, but short of exploiting the physics engine by manipulating the framerate by opening the weapon wheel, you’re not going to see any crazy movement strategies.

Ultrakill has a triple dash, a slide, dash jump, ground pound and the player character can be knocked about by explosions and shock waves. On top of that, there is also the very intricate interplay between these elements due to how the physics engine works.

The result here is a set of extremely complex mechanics that are never set in stone; instead emerging from a few laws of the game that don’t have total death grip control over their domain.

There is no way I could write an article about emergent mechanics without mentioning Quake. So lets do that now.

None of the high level mechanics in Quake are intended. Everything from straferunning, to wallrunning, to rocket jumping, to bunnyhopping and power bunnyhopping (also called strafejumping in the context of Quake) is the result of a few basic rules and wack physics.

“The player can turn”
“The player can move in 8 cardinal directions”
“The player can jump”
“The player can sprint, increasing their speed”
“There are entities that are affected by physics”
“The player is one such entity”

And that’s it as far as I’m aware.

All the of the complex movement mechanics emerge from the interplay of these rules. One of the first that was found was straferunning. What this means is sending both a move-forward and strafe input. Due to the way velocity is calculated, this results in a slight speed increase. Shortly after this, it was discovered that doing this while running into a wall causes a greater speed increase. As did wiggling the mouse left and right. When jumping you don’t lose any momentum. Put all of these together – with the exception of wallrunning – add little finesse on top and the result is strafejumping.

To me there is something about using these emergent mechanics that is infinitely more satisfying than the pre baked equivalents in modern games. Figuring out how to (ab)use the game’s rules to your advantage is half the fun if you ask me and games like Doom Eternal take most of that away from you by giving you one or very few viable strategies to approach a given situation and then telling you most of them from the get go.

Orca

Sat, 09 Sep 2023 15:59:21 +0200

Brainy Music

There’s something I really like about the idea of mathematically and programmatically making music. As a result, I’ve harboured an interest in trackers for quite some time, but never got into attempting to actually use one. In a similar vein, I’ve looked at Hundred Rabbits' Orca every now and then, but once again couldn’t be bothered to figure it out.

That was until recently, due to unrelated circumstances, I got access to Ableton Live. This piqued my interest in Orca again and I decided to grit my teeth and learn the syntax. The result is that I have now produced some blobs of characters that – when paired with the right software – produce some really interesting noises.

I won’t go into detail on how everything works as the documentation is easy enough to read. The syntax is the biggest hurdle.

Patterns

My favourite operator so far is U – the eUclidian rhythm operator. It takes a left and right argument – lets refer to them as X and Y respectively – and then attempts to produce a bang – that is to say pulse on X out of Y frames. So 3U8 attempts to produce 3 equally spaced bangs in 8 frames, which will fail. As a result, it spaces the bangs as close to equal as possible. This can lead to some really interesting patterns and rhythms.

Here’s an example of when I wrapped my head around it for the first time:

Sorry mate, your browser doesn't support playing audio files.

And the Orca code:

..nVC...........
................
5U9..Vn..4U9..Vn
.*:04C....*:03C.
................
3U5..Vn.........
..:05C..........
................
3U8..Vn.........
.*:06C..........

Here’s a variant with a different synth and where I’ve been messing around with the note being played while recording:

Sorry mate, your browser doesn't support playing audio files.

Numbers and stuff

Because I suck at basic calculus and have been half arsedly learning BQN, I wrote a function to get a list of numbers to produce potentially interesting patterns for the U operator:

OrcaList ← {1↕(⊢⋈¨𝕩⊸÷)1+↕𝕩}

This function requires a number and returns a list of all possible divisions from 1 up to the given number.

   Orcalist 9
┌─                          
╵ ⟨ 1 9 ⟩                   
  ⟨ 2 4.5 ⟩                 
  ⟨ 3 3 ⟩                   
  ⟨ 4 2.25 ⟩                
  ⟨ 5 1.8 ⟩                 
  ⟨ 6 1.5 ⟩                 
  ⟨ 7 1.2857142857142858 ⟩  
  ⟨ 8 1.125 ⟩               
  ⟨ 9 1 ⟩                   
                           ┘

Rough Haskell equivalent for readability’s sake:

orcaList x = map ((,) <$> id <*> (x/)) [1..x]

Recording from LMMS

Since LMMS puts whatever MIDI notes it gets into a grid (by default at least), most of the intricacies of timing are lost. As a result, when using LMMS, I use pw-record to record the live audio output with timing still intact.

This audio journey has also lead me to appreciate Pipewire a lot more. In that regard, I have the following audio stack on NixOS:

{ config, ... }: {
  sound.enable = true;
  hardware.pulseaudio.enable = false;
  services.pipewire = {
    enable = true;
    alsa.enable = true;
    alsa.support32Bit = true;
    pulse.enable = true;
    jack.enable = true;
  };
}

And I use qwpgraph as patchbay.

I2p on NixOS

Thu, 27 Jul 2023 00:21:37 +0200

Introduction

Recently I’ve decided to move most of my hardware over to NixOS. It’s been an amazing experience being able to configure everything OS related from one central point.

A few years ago, I discovered i2p. I really liked the idea of it; a different darknet than tor with different kinds of people on it – more blog oriented. At the time I ran a node on a Raspberry Pi running Debian. I connected to it using an ssh tunnel over Yggdrasil and used an Arkenfox hardened Firefox profile to browse around.

That Raspberry Pi no longer serves as a (har) server. Instead I now have a NixOS machine churning away. As with a lot of NixOS topics, there isn’t a lot of documentation on configuring i2p. Though truth be told, when comparing it to the config files I had on Debian, a lot of it was rather self explanatory and easy to implement in a Nix module.

What follows is my current setup on my desktop. Initially I set this up as a test environment, but it works well to the point where I don’t really feel the need to move it to another machine.

The i2p module

I’ll be using the i2pd implementation of the i2p daemon as it requires less resources than the java implementation and has less features out of the box that need configuring.

Since it is safe to assume that the i2p stack is frequently under attack as it is a darknet protocol, I decided to run it inside of a Nix container. If you don’t want to do this, only declare a services.i2pd instance.

With that out of the way, let’s declare a basic container environment named i2pd-container.

{ ... }: {
  containers.i2pd-container = {
    autoStart = true;
    config = { ... }: {

      system.stateVersion = "23.05"; # If you don't add a state version, nix will complain at every rebuild

    };
  }
}

From here there are a couple of things you can do with your i2p configuration. My initial goal was to be able to search the i2p net. To that end, the following will suffice.

...
      # Exposing the nessecary ports in order to interact with i2p from outside the container
      networking.firewall.allowedTCPPorts = [
        7070 # default web interface port
        4447 # default socks proxy port
        4444 # default http proxy port
      ];

      services.i2pd = {
        enable = true;
        address = "127.0.0.1"; # you may want to set this to 0.0.0.0 if you are planning to use an ssh tunnel
        proto = {
          http.enable = true;
          socksProxy.enable = true;
          httpProxy.enable = true;
        };
      };
...

The SOCKS proxy isn’t strictly required, but needed when wanting to use anything else than an HTTP connection to interact with i2p.

Torrents

After a little while, I wanted to see what kinds of linux distros the i2p network has to offer, I also enabled services.i2pd.proto.sam and added the corresponding default port to the container’s firewall in order to get XD (which can be found in the Nix repo) to behave properly:

...
      networking.firewall.allowedTCPPorts = [ 7656 ];
      services.i2pd.proto.sam.enable = true;
...

Click here to see everything together

{ ... }: {
  containers.i2pd-container = {
    autoStart = true;
    config = { ... }: {

      system.stateVersion = "23.05"; # If you don't add a state version, nix will complain at every rebuild

      # Exposing the nessecary ports in order to interact with i2p from outside the container
      networking.firewall.allowedTCPPorts = [
        7656 # default sam port
        7070 # default web interface port
        4447 # default socks proxy port
        4444 # default http proxy port
      ];

      services.i2pd = {
        enable = true;
        address = "127.0.0.1"; # you may want to set this to 0.0.0.0 if you are planning to use an ssh tunnel
        proto = {
          http.enable = true;
          socksProxy.enable = true;
          httpProxy.enable = true;
          sam.enable = true;
        };
      };
    };
  }
}

Tying it to `/etc/nixos/configuration.nix`

I have a perhaps somewhat over engineered structure when it comes to adding my modules to /etc/nixos/configuration.nix.

I have a /etc/nixos/services directory with my own modules, one of which being services.nix. services.nix imports all the other modules found in the directory. From there, /etc/nixos/configuration.nix has ./services/services.nix in it’s import section:

/etc/nixos/configuration.nix:

{ pkgs, config, ... }: {
  imports = [
    ./hardware-configuration.nix
    ./services/services.nix
    ...
  ];
  ...
}

/etc/nixos/services/services.nix:

{ ... }: {
  imports = [
    ./i2pd-container.nix
    ...
  ];
}

Browser profile

The next step was to set up a browser profile. Since Mullvad recently released a browser, I decided to use it as a basis for my i2p browser.

To create a new profile in Firefox or any of it’s forks, type/paste about:profiles in the URL bar and click the “Create a New Profile” button at the top. You will then be prompted for a name. I named mine “i2p”.

Open this profile in a new session and navigate to about:preferencess#general and scroll all the way down to “Network Settings”. In there, check “Manual proxy configuration” and “Also use this proxy for HTTPS”. From there, fill in the address you used in services.i2pd.address or the address of the machine you’re tying it to if you’re using an ssh tunnel. For ports, use 4444 for the HTTP proxy and 4447 for the SOCKS proxy.

Then move over to about:preferencess#privacy and scroll down to “Security”. I recommend putting it to “Safest”. If you really need to run any JavaScript, you can always add the NoScript icon to your window bar.

Then scroll a bit further down to “HTTPS-Only Mode” and disable it, as the i2p network doesn’t use browser level encryption and thus it would only get in the way.

As a final step, go to about:config and set keyword.enabled to false. This isn’t strictly necessary, but will make your like a whole lot easier when typing .i2p domains and not having your browser attempt – and fail – to query the default search engine.

`.desktop` entry via `home-manager`

If you’re using the home-manager, you can quite easily create a .desktop file to make starting your i2p profile more convenient. This is assuming that have either a full on desktop environment or use some other way of parsing .desktop entries such as rofi’s drun mode.

I have the following in my $HOME/.config/home-manager/home.nix:

xdg.desktopEntries = {
  i2p-browser = {
    name = "i2p Browser";
    genericName = "Web Browser";
    exec = "${pkgs.mullvad-browser}/bin/mullvad-browser -p i2p";
  };
};

Firefox and it’s forks allow you to start a session with a profile using the -p parameter. Similarly the -P (that is, an upper case ‘P’ rather than lower case) parameter brings up a profiles menu that allows you to easily change the default profile when running the binary the next time.

Using everything

After starting the container, wait at least 15 minutes for i2pd to build a few tunnels before attempting to connect to anything. Once you have, open your i2p browser profile and you should be able to browse the i2p net. Don’t expect things to be fast however, i2p is a much slower network in my experience than Tor.

Some pages to get you started:

reg.i2p - link index
stats.i2p - link index
notbob.i2p - link index
My site

Ideas

Sun, 26 Mar 2023 22:21:28 +0200

Car bine
Gun named Tommy (Chicago mafia accent)
Pee/Pea shooter

XMonad Promtps

Wed, 08 Mar 2023 14:20:11 +0100

Introduction

XMonad has it’s own prompt system. Some time ago, I wanted to see if it could replace dmenu entirely. I managed it for the more common usages I had for it. My application launcher, ssh prompt and pass interface were easy to replace using standard XMonad Contrib modules (XMonad.Prompt.Shell, XMonad.Prompt.Ssh and XMonad.Prompt.Pass respectively). However, things became more difficult when it came to my universal/external Qutebrowser bookmarks menu and yt-dlp-and-pipe-viewer wrapper.

This tutorial-of-sorts will assume some Haskell knowledge or not being afraid of diving straight into how Haskell works. I’m not going into great detail on how everything works here.

The first one I decided to tackle was the bookmarks menu, as it is by far the simplest of the two.

Let’s take a look at the original:

#!/bin/sh
bookmarks="$HOME/.config/qutebrowser/bookmarks/urls"
choice="$(awk '{print$1}' $bookmarks | sort | dmenu -p "Bookmark:" -l 30)"
[ -z $choice ] || qutebrowser "$choice"

Things get interesting at the initialisation of the choice variable:

It takes the contents of Qutebrowser’s bookmarks file
It sorts the results of that
Sends that to dmenu, prompting the user to make a choice

After this, it checks whether choice is empty or not and in case it isn’t, opens Qutebrowser with its contents.

Here is an example of how Qutebrowser saves its bookmarks:

https://www.alpinelinux.org/ index | Alpine Linux
https://www.openbsd.org/ftp.html OpenBSD: Mirrors
https://commonmark.org/ CommonMark
https://xxiivv.com/ Echorridoors
https://100r.co/site/home.html 100R — home
https://solar.lowtechmagazine.com/about.html About this website | LOW←TECH MAGAZINE

Implementation

Its functionality does boils down to the following:

Parse a given file according to a set of rules, returning it’s contents in the form of a list
Allow the user to make a choice from that list
Launch an application with that choice as parameter

Seems easy enough to implement.

Parsing the Bookmarks file

Let’s start off by creating a function that can parse our bookmarks file. Here we need something to read a file – in this case a bookmarks file – and return its contents in the form of a list of strings.

fileContentList :: FilePath -> IO [String]

This function takes a filepath – the Filepath datatype is an alias for String – and returns IO [String].

Now for the body of the function:

fileContentList :: FilePath -> IO [String]
fileContentList f = do
    homeDir <- getEnv "HOME"
    file <- readFile (homeDir ++ "/" ++ f)
    return . uniqSort . lines $ file

Let’s go over what is happening here line by line.

fileContentList is a function that takes an argument f; then it starts a do block. do blocks are used to put multiple functions in sequence in the scope of a single function without having them interact with eachother.

Within the do block, it first retrieves the current home directory based on the $HOME environment variable and binds it to homeDir using the getEnv function from the System.Environment module. getEnv returns a string with the contents of the variable given as its argument.

Next, it retrieves the file contents from $HOME/path/to/file using the readFile. This path is created by appending f to the homeDir.

Now for the final line.

First it takes the file and splits it up into a list of strings based on newlines using the lines function.

    lines $ file

Then it pipes the result from that into uniqSort from the XMonad.Prompt module in order to – as the name implies – sort it and get rid of any duplicate items.

    uniqSort . lines $ file

And the output of that is piped into return:

    return . uniqSort . lines $ file

This function will allow us to parse any given text file. To parse the Qutebrowser bookmarks file, call it using .config/qutebrowser/bookmarks/url

Note: I say “pipe” because the ‘.’ function behaves quite similar to pipes in POSIX Shell. However, the correct way of referring to what it does is composition; it takes two functions and passes the output of the first function to the second, thereby creating – or composing a new function. As apposed to how pipes in POSIX Shell work, function composition chains are executed from right to left.

Creating a Prompt

Let’s see if there is anything in the XMonad.Prompt module that looks like it could help us in creating a prompt.

mkXPrompt :: XPrompt p => p -> XPConfig -> ComplFunction -> (String -> X ()) -> X ()
Creates a prompt given:

a prompt type, instance of the XPrompt class.

a prompt configuration (def can be used as a starting point)

a completion function (mkComplFunFromList can be used to create a completions function given a list of possible completions)

an action to be run: the action must take a string and return X ()

This looks like it could serve as the basis for our prompt. The description and type signature tell us that it is going to require an instance of the XPrompt typeclass. So let’s create a Bookmark datatype and implement the showXPrompt function from XPrompt in order to give it a default message when executed and thereby having it derive from XPrompt.

data Bookmark = Bookmark

instance XPrompt Bookmark where
    showXPrompt Bookmark = "Bookmark: "

As its second argument, mkXPrompt requires an instance of XPConfig. The XPConfig typeclass is where you – as the name implies – specify the configuration of XMonad’s prompts. Knowing this we can start to write function that uses mkXPrompt:

bookmarkPrompt c = do
    mkXPrompt Bookmark c

c is our XPConfig argument.

This takes care of the XPrompt p => p -> XPConfig portion of the function.

Now for the completion function, that will handle the list given to our prompt. Let’s mostly follow the suggestion in the description of mkXPrompt and lets take a look at:

mkComplFunFromList' :: XPConfig -> [String] -> String -> IO [String]
This function takes a list of possible completions and returns a completions function to be used with mkXPrompt. If the string is null it will return all completions.

This is how Qutebrowser and dmenu act by default with a given list of possible options.

bookmarksFile = ".config/qutebrowser/bookmarks/urls" :: String

I didn’t know where to put this, but I created a string to hold the path to my bookmarks

So it takes an instance of XPConfig – that will again be our c argument, and a list of strings. Here is where we feed it the contents of our file using our fileContentList function. We will do this by binding the output to, say bl for “bookmark list” with <-. Since fileContentList is a member of the IO monad and we’re working in, we have to call it using the io function, which is an alias for the liftIO function.

bookmarkPrompt :: XPConfig -> (String -> X ()) -> X ()
bookmarkPrompt c f = do
    bl <- io fileContentList bookmarksFile
    mkXPrompt Bookmark c (mkComplFunFromList' c bl) f

You’ll see that I’ve also added argument f, this is the function we’re going to use to actually do something with our prompt output. Considering we’re working with bookmarks, opening them in a browser would make sense.

openBookmark :: String -> X ()
openBookmark bookmark = do
    browser <- io getBrowser
    spawn $ browser ++ " '" ++ getUrl bookmark ++ "'"
        where getUrl = head . words

openBookmark is a function that takes a string and returns something in the context of the X monad (hence the name “XMonad”, it’s a monad that interacts with Xorg). Let’s go through it line by line.

    browser <- io getBrowser

First we get user’s browser using the getBrowser function from the XMonad.Prompt.Shell module and bind that to browser.

This function checks the $BROWSER environment variable and if it isn’t set, it defaults to “firefox”.

    spawn $ browser ++ " '" ++ getUrl bookmark ++ "'"

Since getBrowser returns a string, we can append things to it and feed that to spawn. In this case, we get the URL portion of the bookmark entry surrounded by single quotes in case a given bookmark contains any symbols that mess up our shell. After all, what spawn ultimately does is feed a given string to /bin/sh as a command to execute.

        where getUrl = head . words

For get getUrl, we take the given string, split it into a list of strings based on space characters, pipe that into head, thus retrieving the first item.

Keybinding

We now have a set of functions that create a prompt populated with our Qutebrowser bookmarks file (any other list of URLs will also work) which will open our browser when choosing one.

Now all we have to do is bind it to a key. Personally I use the XMonad.Util.EZConfig so I have the following in my keybindings:

, ("M-M1-C-b", bookmarkPrompt (myXPConfig {autoComplete = Just 200000}) openBookmark Bookmark)

If you use the default way of defining keybindings you can use something like the following:

, ((modm .|. controlMask, xK_b), bookmarkPrompt def openBookmark)

def is a reference to the default implementation of XPConfig.

Everything Together

Everything put together, your config should have something like the following added.

data Bookmark = Bookmark

instance XPrompt Bookmark where
    showXPrompt Bookmark = "Bookmark: "

bookmarksFile = ".config/qutebrowser/bookmarks/urls" :: String

fileContentList :: FilePath -> IO [String]
fileContentList f = do
    homeDir <- getEnv "HOME"
    file <- readFile (homeDir ++ "/" ++ f)
    return . uniqSort . lines $ file

bookmarkPrompt :: XPConfig -> (String -> X ()) -> X ()
bookmarkPrompt c f = do
    bl <- io fileContentList bookmarksFile
    mkXPrompt Bookmark c (mkComplFunFromList' c bl) f

openBookmark :: String -> X ()
openBookmark bookmark = do
    browser <- io getBrowser
    spawn $ browser ++ " '" ++ getUrl bookmark ++ "'"
        where getUrl = head . words

-- ... keybindings
, ((modm .|. controlMask, xK_b), bookmarkPrompt def openBookmark)
-- more keybindings ...

On window managers and XMonad

Thu, 03 Nov 2022 23:17:35 +0100

My journey into Tiling Window Managers

When I started my Linux journey, I stuck with GNOME 3 something for around the first year. Sure, I tried KDE and Cinnamon and XFCE, but GNOME is the one I always kept coming back to. I think it’s because it’s pretty much the only one that felt completely different from what the rest of the world was doing. It helped me with thinking about Linux as being different from windows. After this first year though, I came across a few videos about tiling window managers and wanted to try one. The first one I installed was i3.

I hated it.

I had a hard time configuring it as I didn’t really know what I was doing. Other than that, I found it plain awkward to use. The way it tiles windows – and how you still have to babysit pretty much every last one of them – drives me away from i3 to this day. I’m sure it has the potential to be a great window manager. It’s just really not for me. Which is a shame, I would really like to properly live in Wayland with Sway for at least a little while.

After a few hours of trying to get things to work in i3, I went back to GNOME. Some time later, I came across AwesomeWM. It was being recommended as a fairly easy window manager to start with – it having window decorations and it’s own menu system. The first thing I did was try-and fail to rip out said menu system and window decorations. I was putting too much on myself trying to learn the basics of both using a tiling window manager and Lua.

Some time after that, I came across BSPWM. This was the first time where I felt like I really managed to get a tiling window manger to do what I wanted it to do. For some odd reason, there are people out there who consider BSPWM a more “advanced” window manger. I really don’t get why. To this day, I am of the opinion that SXHKD’s configuration syntax is some of the best out there. I think it took me around 10 minutes to wrap my head around the basics. Somewhere around an afternoon later, I had a config that served me well for the next few months to come.

A while after BSPWM, I decided to give suckless' DWM a shot. Despite my lack of knowledge of C, this very quickly became my favorite window manager at the time. There is just something about the insanity of using diff files to configure your piece of software when perfectly functional configuration libraries and languages exist that got it’s hooks in me. I also caught the minimalism bug around this time, so DWM’s nearly non-existent memory footprint was also great. Despite this really being the first really “advanced” window manager, I had an easier time configuring it than AwesomeWM or i3. It was also the first time where I could appreciate the master-stack layout properly and not having to think about keeping track of windows in two dimensions anymore. It made me realise that I want to have to think as little as possible about window positioning. It was the reason I couldn’t deal with i3’s paradigm and shifted away from BSPWM the moment I found DWM.

I ran DWM as my main window manger for over a year before having issues with some fullscreen applications and the JetBrains suite, which I had to use for college activities.

I decided to give AwesomeWM another shot after having figured out what I want from a tiling window manger. This time I managed to get something that worked pretty much exactly how I wanted it to. In other words, a fairly basic configuration with most of the default features ripped out and instead my partially-organically-grown-probably-batshit-insane-keybindings (I use Super + Space to open my run launcher. In fact, on my keyboard I have holding the big space bar (yes it has two space bars, its layout is about as insane as my window management keybindings) bound to Super + Space).

To this day I still use DWM quite frequently on machines where I don’t really want to think about what graphical interface to chuck on it (hence I half arsedly maintain an Alpine package of my fork).

For quite a long time I used DWM and AwesomeWM depending on whether I was planning on frequently using fullscreen applications and how strong the machine in question was; AwesomeWM being noticeably slower than DWM on really old machines (like RejuvinatedBrick). Until at some point, I came across XMonad.

I tried it for an evening.

I hated the fact that it’s configured in sodding Haskell and went back to DWM.

A few months later, I came across an implementation of chorded keys through the XMonad.Util.EZConfig module and decided to give it another shot.

This time I was hooked.

The biggest problem I had with it was still the fact that it was configured in Haskell, but the absurd level of customisability made it worth dealing with the functional pain. It was also the first time I decided to not bother with a status bar as getting a basic configuration going had given me enough grief for one month.

As for gripes I had (and partially still have) with XMonad, they were quite few, surprisingly. Coming from AwesomeWM and DWM, I would’ve liked XMonad to use tags instead of workspaces; fullscreen is a bit of a pain to get working, but has less fuckups than DWM; the fact that it’s configured in Haskell; it not having a set of workspaces per monitor (at least by default, I kind of stopped caring after a little while); the fact that it’s configured in Haskell; the XMonad.Layout.ShowWName module being kind of unstable and last but not least, the fact that it’s configured in fucking Haskell.

It almost seems like I got sick of being sick of it being configured in Haskell and I decided to dive into learning the language with the goal of being able to fully understand my monstrous 384 line config file (586 lines including the documentation in commented sections).

I don’t fully understand it yet at the time of writing, but I do understand it a hell of a lot better than when I produced most of those 300 lines.

The greatest thing about XMonad is simultaneously the thing that kept me away from it: it’s written and configured in bloody Haskell. Thus there is barely a separation between configuration and source code. The only difference there really is, is the filename. Once you understand a bit of Haskell (no small task if you’re used to imperative languages) adding and integrating your own features is really easy. And then they are properly integrated. Sort of like how DWM works, only with proper documentation and support. Part of me wants to see if I can figure out a way to package my XMonad build as a single binary to be able to chuck it onto systems without putting much thought into it.

Weird thing with Haskell I’m noticing so far is that I’m slowly but surely managing to dig up old concepts that I tried to implement in imperative languages, but couldn’t due to their nature. Things like pattern matching and maps are quite intuitive to me. It’s just that Haskell’s syntax takes a lot of getting used to. In the mean time, I guess that my experience with POSIX Shell bridged the gap between my knowledge of Go and C#; and Haskell.

I highly recommend giving XMonad a shot if you’re willing to bash your head against the Haskell wall for a while before understanding how your window manager works.

Looking back I find it quite funny to see how I went from not being able to get i3 to do what I wanted it too and giving up; to barely being able to write or understand Haskell but putting up with it.

PWR Switch

Fri, 14 Oct 2022 10:50:56 +0200

Introduction

As we all know, the “S” in IOT stands for security. We’ve all seen countless stories of people’s networks getting hijacked due to some 3 year old vulnerability in the software stack of their insert smart device here. These things barely get any patches at all. On top of that, the most they do is spy on you and send your footage to the police without asking for your consent.

Still, on the other hand, it can be really convenient to be able to control some of the electronics in your home without having to walk towards them. I personally have a lamp that I frequently forget to turn off when leaving my room. The solution was an Olimex PWR-switch in combination with a Raspberry Pi 4 that I have running 24/7 regardless (mostly to watch YouTube videos and listen to music over my speaker set; I might write a post about this beautifully hacky contraption at some point in the future).

Setup

Setting it up was relatively easy.

First I connected a European extension socket to a random 230 volt cable I still had laying around. Then I hooked that up to my PWR-switch and plugged my lamp into that contraption.

From there I got little bag of jumper wires from my local electronics store and hooked up the PWR-switch to my Raspberry Pi. I hooked up the PWR-switch’s positive to GPIO 15 and it’s ground to the preceding ground pin. Here’s a reference page.

Note, GPIO 15 is in reference to pin number 10 and the preceding ground pin is pin number 6.

From there I looked up how to send power to GPIO 15 in order to have it toggle to the “on” state. The first step to this end is to initialise the pin. This can be done with:

echo 15 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio15/direction

Then, sending power to it can be done using something like…

echo 1 > /sys/class/gpio/gpio15/value

…and the opposite can be done using:

echo 0 > /sys/class/gpio/gpio15/value

Deinitialising the pin can be done with:

echo 15 > /sys/class/gpio/unexport

To make this all a little easier I have written a wrapper in POSIX Shell:

Click to see script

#!/bin/sh

INIT_PIN(){
	# the PWR-SWITCH is connected to GPIO 15 and the preceding ground pin
	# reference page https://pinout.xyz/pinout/
	[ -d /sys/class/gpio/gpio15 ] && echo "Pin already initialised" && exit 0
	echo 15 > /sys/class/gpio/export
	echo out > /sys/class/gpio/gpio15/direction
}

DEINIT_PIN(){
	[ -d /sys/class/gpio/gpio15 ] || echo "Pin not initialised" && exit 0
	echo 15 > /sys/class/gpio/unexport
}

PIN_STATUS(){
	if [ -d /sys/class/gpio/gpio15 ] ; then
		echo "pin status: Pin initialised"
	else
		echo "pin status: Pin not initialised"
	fi
}

SWITCH_ON(){
	# initialise pin before doing anything
	[ -d /sys/class/gpio/gpio15 ] || INIT_PIN
	echo 1 > /sys/class/gpio/gpio15/value
}

SWITCH_OFF(){
	# initialise pin before doing anything
	[ -d /sys/class/gpio/gpio15 ] || INIT_PIN
	echo 0 > /sys/class/gpio/gpio15/value
}

TOGGLE_SWITCH(){
	# initialise pin before doing anything
	[ -d /sys/class/gpio/gpio15 ] || INIT_PIN
	case $(cat /sys/class/gpio/gpio15/value) in
		1) SWITCH_OFF;;
		0) SWITCH_ON;;
	esac
}

USAGE(){
	cat >&2 <<EOF
Usage: pwr-switch <on|off|init|deinit>
	on: send on signal
	off: send off signal
	init: initialise pin
	deinit: deinitialise pin
	status: show pin initialisation state
	toggle: toggle on/off signal
EOF
}

case $1 in
	on) SWITCH_ON;;
	off) SWITCH_OFF;;
	init) INIT_PIN;;
	deinit) DEINIT_PIN;;
	status) PIN_STATUS;;
	toggle) TOGGLE_SWITCH;;
	*) USAGE;;
esac

You could probably also do this in Python, but my knowledge of Python is nearly none.

Remote interaction

You can probably make a guess as to how I set up the automation and interaction from other devices. That’s right, I used an SSH forced command:

no-pty,command="/usr/local/sbin/pwr-switch toggle" ssh-ed25519 <contents of <lamp-key>.pub>

The unique thing here being that it needs to be executed as the root user in order to mess with the state of the pins. (Or at least in the case of my setup.) So having it be a forced command is a security benefit here as it prevents whatever device you’re using to toggle your lamp from having to log in as the root user. All a device with the <lamp-key> can do, is toggle the state of GPIO 15.

You could contrivedly call this SIOT…

Since Android 12, there is the “Device controls” tile in the swipe-down-from-the-top-of-the-screen-menu. Termux can interact with the API that this system provides and allows you to add buttons corresponding to Termux’ shortcuts. These shortcuts are executables found in ~/.shortcuts within the Termux environment. Here I’ve created a little script that logs into my Raspberry Pi using the <lamp-key>, allowing me to toggle my lamp at the tap of a button as long as I’m on my home network.

Hosting your own Git "server"

Fri, 30 Sep 2022 14:27:31 +0200

Introduction

Pretty much the moment I started to work with Git a few years ago, I’ve wanted to host my own server. I didn’t really bother looking into how that could work for a very long time. I assumed it would be rather complex considering Git itself is an extremely complex (set of) tool(s) to work with. I was hilariously wrong. It’s so simple to me that I’m under the impression that the lack of posts regarding the topic on blogs like this, is because it’s so simple. Still, I’m going to spend the rest of this post explaining how to set up a server and why even calling a basic configuration a server, is a bit of an exaggeration.

Setting up the server

The first step is to set up a Unix box of any kind. Linux, any of the BSDs and probably even Darwin will work (hell, even Haiku might suffice). The rest of this post assumes a Debian system (or rather, that you have the core GNUtils available). Basics requirements are quite few:

It needs to be accessible using SSH.
It needs Git installed.

Adding an account

Common practice dictates that you have a dedicated account for managing your Git repositories. Common practice again dictates that this account be called git. Its home directory doesn’t really matter, but I like tossing it into /srv/git. Login shell also doesn’t matter yet, I tend to change it to bash for when I need to do things as the git user.

You can create an account with the following:

sudo useradd git -md /srv/git -s /bin/bash

-d specifies where the home directory should be
-m creates the home directory
-s specifies what binary to use as login shell

Setting up SSH

Client side

On the machine from where you want to push your git repositories, generate a new SSH key to access your Git server:

ssh-keygen -t ed25519 -f ~/.ssh/<git-key>

I also recommend creating an entry in ~/.ssh/config for your Git server:

Host <host>-git
	Hostname <hostname>
	User git
	Identityfile ~/.ssh/<git-key>

Server side

Next step is to make the git account accessible over SSH. ssh-copy-id won’t work because the git user doesn’t have a password. So instead, log in as the git user and create a .ssh directory with an authorized_keys file with the public half of the <git-key> keypair:

sudo su - git
umask 077 # strict read write permissions
mkdir ~/.ssh
cat <git-key>.pub >> ~/.ssh/authorized_keys

Adding a repository

You should now be able to log into your host as the git user with using <git-key>. Setting up the route from client to server is half the work.

Next step. Make this actually serve Git repositories. All this requires is a bare Git repository somewhere within /srv/git. To do this, log in as the git user and run:

git init --bare <repo-name>.git

That’s it.

You now have a Git “server” with a repo named <repo-name>.

To add something to this repo, on your client machine create a new repository and add <host>-git:/srv/git/<repo-name>.git as remote and push your project to it. Common practice dictates that this remote be called origin:

mkdir my-fancy-project
cd my-fancy-project
git init
git remote add origin <host>-git:/srv/git/<repo-name>.git
echo "# Self-hosted repo!" > README.md
git add -A
git commit -m "Initial commit"
git push -u origin main # assuming you use main as your default branch name

To clone this repository on another machine, add the <git-key> SSH keypair and related configuration section in ~/.ssh/config to said machine and run:

git clone <host>-git:/srv/git/<repo-name>.git

Automation

Creating bare repositories by hand gets annoying quite quickly. I have an SSH forced command for another key that runs a script with the following:

#!/bin/sh

BASELOC="/srv/git"
echo "Enter new repo name:"
read REPONAME
[ -z $REPONAME ] && echo "No repo initialised" && exit 1
git init --bare $BASELOC/$REPONAME.git

authorized_keys entry for git user:

command="/srv/git/.bin/new-repo" ssh-ed25519 <new-repo-git-key>.pub

Another thing you could do is change the login shell binary to a script that does something similar. I haven’t bothered to do so for reasons that presently escape me.

SSH Configuration

Tue, 27 Sep 2022 11:40:31 +0200

Introduction

If you’re anything like me, you’ll have at least a hand full of servers you’ll log into (at least) every now and then using SSH. These servers don’t all have the same key. And on top of that, I frequently have multiple keys per host. Managing this by hand is a pain in the arse. Thankfully there are a few tools that make it a breeze. I will be going through what I have done to both my local configuration and what I tend to do with my server configuration.

Generating keys

In order to do anything with SSH in a secure way, you’ll need to make use of public and private keys. These keypairs are generated using ssh-keygen. I typically generate mine using:

ssh-keygen -t ed25519 -f ~/.ssh/<new-key>

Without any parameters, it will generate an rsa3072 key. This form of cryptography isn’t recommended as it’s become a bit flimsy with computers becoming stronger. Instead I recommend at least adding the -t ed25519 flag to generate a ed25519 key.

When prompted for a passphrase, always give it one. The only situation where not using a passphrase is acceptable is when you are planning on using the key for a forced command.

Server Configuration

This is all done under the assumption that the you use the OpenSSH implementation on your server. If you use something like Dropbear, I can’t help you as haven’t properly dug through it’s configuration file (yet).

The things I see way to often on the internet are…

People not disabling password authentication.
People not changing the default port.
People not disabling root login and never using it.

So lets go through these steps one by one.

Password Authentication

Password authentication is the most basic thing every server should have disabled. Otherwise, it is possible to brute force a connection into your server.

“But my server is not exposed to the internet.”

I guess you could get away with not disabling password authentication, but it’s still not a good idea in case, say, your network gets compromised. On top of that, it’s less convenient to have to type in a password every time you want to log into your server (more in that in the SSH Agent section).

In order to disable password authentication, open your SSH daemon configuration file: /etc/ssh/sshd_config and look for the following lines…

...
# To disable tunneled clear text passwords, change to no here!
#PasswordAuthentication yes
#PermitEmptyPasswords no
...

…uncomment PasswordAuthentication and replace “yes” for “no”. Make sure you still have a way into your server before restarting the daemon.

If you’re not planning on logging in as the root user, uncomment and set the following setting to “no”.

...
#PermitRootLogin prohibit-password
...

Be aware of the fact that you can still utilise the root account using sudo su - (assuming you’re using sudo on your server, else use whatever other privilege escalation tool you have at hand).

Restarting the daemon on modern systems is usually done using:

systemctl restart sshd

If you’re not using systemd, I’m sure you know what command to use instead.

Adding keys to `authorized_keys`

When going through /etc/ssh/sshd_config you’ve probably come across a few lines resembling:

...
# Expect .ssh/authorized_keys2 to be disregarded by default in future.
#AuthorizedKeysFile     .ssh/authorized_keys .ssh/authorized_keys2
...

This means that the SSH daemon will check in .ssh/authorized_keys in the home directory of the user as whom you’re trying to log in for authorized keys. So the next step is to append your public key to this file in the home directory of the user as whom you want to be able to log in. This can be done in a few ways. The proper way is by using:

ssh-copy-id -i ~/.ssh/<key-file> <user>@<host>

I’m usually too lazy to remember there is a proper way and just open the file in vi paste and it in there by hand during the same initial login when I’m disabling password authentication. Either way works fine.

Changing the port

The advantage to this is that your logs will be a lot cleaner if your host is exposed to the internet. There are large amounts of bots hammering port 22 on every IP address they can find with common usernames and passwords like “root” and “admin”. A solution next to this is to use fail2ban along side changing the port.

“Won’t this mean I have to add the port to my login command every time I go to this server?”

No, more in this in the client configuration section

In /etc/ssh/sshd_config look for…

...
#Port 22
#AddressFamily any
#ListenAddress 0.0.0.0
#ListenAddress ::
...

…and change the Port to your liking, I tend to change this to something like 6969 or some other meme number.

Another thing I tend to do is not open a port in my firewall, thus preventing any normal outside connections all together. Instead opting to only connect over Yggdrasil and/or Tor.

Client configuration

If people tend not to think much about their server configuration, their client configuration is probably not even touched at all.

The `~/.ssh/config` file

The very first thing I do after setting up a server, is add an entry to my ~/.ssh/config in order to manage its key, the user, the port and possibly subdomain should the need arise.

A basic configuration section looks like the following:

Host <host> # this is something you can easily identify
	Host <hostname> # this does need to be an IP address or DNS record pointing to an IP address
	IdentityFile ~/.ssh/<key-file>
	User <user-name>
	Port <meme-number>

This allows you to log into host <host> with on port <meme-number> with key ~/.ssh/<key-file> as user <user-name> without by typing:

ssh <user-name>@<hostname> -p <meme-number> -i ~/.ssh/<key-file>

Instead the following command will work:

ssh <host>

More information on the SSH config file can be found in the ssh_config manpage.

Some other frequently used settings for me are:

AddKeysToAgent
IdentitiesOnly
ProxyCommand

`AddKeysToAgent`

Automatically adds the key to your SSH agent if you have one running.

This is useful if you frequently log in and out of a certain host and don’t want to take the time to add it’s key to your agent manually.

`IdentitiesOnly`

Ignore whatever keys your agent has and only use the contents of IdentityFile.

Useful for when you want to be able to log into the same host using multiple keys while using an SSH agent session.

`ProxyCommand`

Always connect to your host using a proxy, using a given command.

Useful for when you can only access a host through a certain proxy.

I use this for my Tor hosts:

Host tor-<host>
        Hostname <lengthy-56-character-string>.onion
	# this is dependent on the netcat implementation of the OpenBSD project, often packaged as "netcat-openbsd"
        ProxyCommand nc -X 5 -x localhost:9050 %h %p # this assumes you are running a tor proxy on your local system and attempts to make a connection through that
        Identityfile ~/.ssh/<key-file>
        User <user>

The SSH Agent

If you’re using SSH keys with passphrases, it will very quickly get annoying to type in the passphrase every time you use a certain key. To alleviate this tedium, the SSH agent exists.

If you’re using a full desktop environment, chances are that you already have an SSH agent running in the background. You can check this by seeing if $SSH_AGENT_PID is set to anything.

echo $SSH_AGENT_PID

If this isn’t set to anything, you can start an agent session by running:

eval $(ssh-agent)

Now you can add keys to your agent with:

ssh-add </path/to/key-file>

You can also have it automatically drop keys after a specified amount of time with the -t flag. I tend to do this with my root keys as a security precaution.

ssh-add -t 1h ~/.ssh/<root-key>

Starting an SSH agent every time you open a new shell session gets quite annoying quite quickly. There are a few things you can automate this. The simplest is to add eval $(ssh-agent) to your ~/.profile. Another option, the one I prefer, is to use keychain from the Funtoo project. It checks whether there’s an agent running every time you start a new login session. If there is, it sets the SSH agent environment variables to the existing ones from some other session. If there isn’t a running SSH session, it will start one.

I have the following in my ~/.profile:

...
eval $(keychain --agents 'gpg,ssh' --eval)
...

As you can see, it can also keep track of your GPG agent.

Forced Commands

Another amazing feature of SSH is forced commands. The name is relatively self explanatory. You give a public key the privilege to execute a single command and nothing else. This is really useful if there is something that you frequently do on a server which is simple enough that it can be automated but still requires interaction from device.

I make use of a forced command to open NCMPCPP on my MPD server. Logging in every time and typing ncmpcpp every time I wanted to add or remove some songs from the current playlist got annoying really fast.

On my client machines I have an entry in my ~/.ssh/config with roughly the following:

Host <host>-radio
	Hostname <hostname>
	User <mpd-user>
	Port <meme-number>
	Identityfile ~/.ssh/<host>-radio
	IdentitiesOnly yes # here's where forcing it to ignore the ssh agent comes in useful

On my MPD server, I have the following in ~/.ssh/authorized_keys:

command="ncmpcpp" ssh-ed25519 <contents of <host>-radio.pub>

When I ssh to <host>-radio, all I get is an NCMPCPP session.

On one of my Raspberry Pis, I make use of a forced command to toggle my desk lamp using a little wrapper I wrote around the Pi’s GPIO interface. It has the following line in ~/.ssh/authorized_keys:

no-pty,command="/path/to/script/lamp toggle" ssh-ed25519 <contents of lamp-key.pub>

The no-pty option prevents any sessions opened with this key from starting an interactive shell session.

Documentation of the authorized_keys file can be found in the sshd manpage under the AUTHORIZED_KEYS FILE FORMAT section.

Nix Home Manager

Mon, 19 Sep 2022 21:49:46 +0200

The Home Manager

The Nix Home Manager is a way to work with Nix in a declarative environment to manage your dotfiles and user environment packages. This can be used on any system running the Nix packagemanager. Personally, I’ve started to dabble around with it a bit after installing the Nix packagemanager in my Alpine installation. Since I’ve already dabbled with Nix on a few systems through NixOS, I already knew the basics of functionally managing packages (or derivations) with the Nix packagemanager. Hence I really quickly got sick of installing packages the imperative way. After looking around for a bit, I found some post mentioning that managing packages in a functional environment outside of NixOS is a bit of a hack. The post referred to some other sources, one of which used a custom meta package and another referred to the Home Manager.

I had messed around with the Nix Home Manager a tiny bit before, but never really gave it a chance to shine as I didn’t really understand it. This time around, I decided to look up some tutorials and see how it worked. When going through the instructions of either tutorial I used, I quickly came to the realisation why I had never really looked at it. Both tutorials took a lot of unnecessary steps according to the author’s will and assumed that everyone following their tutorials had the same preferences as them. I obviously don’t. So here’s my take on installing the Home Manager outside of NixOS.

Actually using Home Manager

Assuming you’re continuing from my previous article on Nix, the first step is to go to the Home Manager github page and go to the page regarding the standalone installation.

From there, things will be quite self explanatory if you’re used to the (bare) basics of NixOS. Though instead of using /etc/nixos/configuration.nix you’ll be using $HOME/.config/nixpkgs/home.nix by default. A basic Home Manager installation will leave you with a home.nix file with the following content:

{ config, pkgs, ... }:

{
  # Home Manager needs a bit of information about you and the
  # paths it should manage.
  home.username = "$USER";
  home.homeDirectory = "/home/$USER";

  # This value determines the Home Manager release that your
  # configuration is compatible with. This helps avoid breakage
  # when a new Home Manager release introduces backwards
  # incompatible changes.
  #
  # You can update Home Manager without changing this value. See
  # the Home Manager release notes for a list of state version
  # changes in each release.
  home.stateVersion = "22.05";

  # Let Home Manager install and manage itself.
  programs.home-manager.enable = true;
}

After making any changes to your home.nix file, you can apply them with:

home-manager switch

If you first want to see whether you build is going to be successful or not, run:

home-manager build

Installing packages

To add some packages, you’ll need to add them to the home.packages array. On my Alpine installation I have the following:

...
  home.packages = with pkgs; [
    brave
    vscodium
  ];
...

Notice the with pkgs; section. This prevents you from having to add the pkgs prefix to every package you want to add. I don’t think this is the idiomatic way of adding packages to your configuration, but it allows me to be a bit lazier and it hasn’t caused any breakages yet.

Managing dotfiles and configuration

Another amazing thing the Home Manager can do is manage your dotfiles. And this in turn can be managed with Git. More on this later.

Git configuration

For instance, I have it manage my Git config using the git module. To do this, I have the something like the following in my home.nix:

...
  programs.git = {
    enable = true;
    ignores = [ "*.swp" ]; # I don't need to see that I still have a file open in vim
    signing = {
      key = "<gpg-fingerprint>";
      signByDefault = false; # it would probably be better for security to have this be true, but doing so gets annoying really fast
    };
    userEmail = "<user-email>";
    userName = "<user-name>";
    extraConfig = {
      init = {
        defaultBranch = "main";
      };
    };
  };
...

Here’s the list of options supported by the git module.

I strongly recommend digging through the documentation, looking for things that interest you in your current situation and setup.

Integrating existing (dot)files

The Home Manager can also manage arbitrary (dot)files for you. I have it link my .zshrc into place with the following line:

...
  home.file.".zshrc".source = ./zshrc;
...

This looks for a file called zshrc in the same directory as home.nix. From there, it symlinks it to ~/.zshrc

It can also manage recursive file structures. I have it keep track of my sxiv configuration with the following few lines:

...
  home.file.".config/sxiv" = {
    source = ./sxiv;
    recursive = true;
  };
...

The interesting portion of this snippet is the recursive boolean. Because of this, Home Manager will recreate the directory structure found in ./sxiv in ~/.config/sxiv and symlinks the files found inside into place.

Git integration

Since all the Home Manager requires is (at least) a single text file to manage your dotfiles and Nix environment packages, it’s really easy to keep track of your configuration using Git. To that end, I have a bare repository on one of my home servers over at /srv/git/nix/<nix-configuration>.git As a remote, I have pointed my repo in $HOME/.config/nixpkgs/ to <server-name>:/srv/git/nix/<nix-configuration>.git. This works over ssh. My $HOME/.ssh/config contains the following lines to make the preceding work:

Host <server-name>
	Hostname <ip-address>
	User git
	Identityfile ~/.ssh/<private-key>
	Port 4242
	IdentitiesOnly yes # this makes using an ssh agent a bit easier when using multiple keys on the same host

Nix on Other Distros' Packagemangers

Mon, 12 Sep 2022 11:37:11 +0200

Introduction

The Nix package manager is an amazing tool that allows you to manage your packages through a purely functional environment. I’m not going to get into why it’s amazing or how it really works in this article. This is purely a guide to installing it in Alpine and Debian Linux.

“Why not use the official instructions?”

The official instructions require you to curl a script directly into sh. From there it requires sudo privileges to install the package manager itself. This sets of a load of alarm bells in terms of security and what it’s going to do from there. As the Nix package manager is packaged for both Debian and Alpine, my two favourite distros next to NixOS, there is no real reason not to use their respective package managers.

When you try to install Nix on Alpine using the aforementioned installation script you also get the warning that it only supports systemd and that you’re on your own when it comes to getting it to work on any other init system (Alpine uses OpenRC). This problem is fixed in the Alpine package.

Then there is also the benefit of of being able to remove it with either apt autoremove --purge nix-setup-systemd or apk del nix instead of having to run said same script a second time.

Yes, I’m aware that you don’t have to curl the script directly into sh and that you can download it to your local system to see what it’s actually doing. But that doesn’t take away from the fact that the official instructions tell you to perform an inherently insecure set of actions by trusting what is effectively a random script on the internet.

“Doesn’t this mixing of packagemanagers cause a huge amount of anomalies?”

No, that’s part of the beauty of Nix. Pretty much everything it does lives in /nix and is softlinked into place, meaning it never interferes with your existing package manager.

DISCLAIMER: Debian Stable at time of writing has Nix version 2.3.1, which appears to have some issues that would be fixed by moving to a later version. Using the official instructions would sidestep this.

Installation Process

Package Installation

The first step is to install the package itself. On Debian this is done with:

sudo apt install nix

On Alpine, you first have to add the testing repo. This is part of the edge branch. As far as I know, you could in theory get away with just adding the testing repo and not moving the rest of your system over to edge, but I highly doubt that will do any good for the stability of your system.

Moving your system over to the edge branch is done by opening /etc/apk/repositories, uncommenting the mirrors referring to edge and commenting out the lines referring to (at time of writing) version 3.16.

From there, run…

doas apk -U upgrade

…to move your system over to edge.

Now installing Nix can be done as usual with:

doas apk add nix

This will install the required binaries and the Nix daemon.

Starting the Daemon

On Debian the Nix daemon is enabled by default. To make sure it’s running and enabled, run:

sudo systemctl status nix-daemon.service

If for whatever reason it’s not started and/or enabled, run:

sudo systemctl enable --now nix-daemon.service

On Alpine, the daemon isn’t added to any run level by default. This is done using:

doas rc-update add nix-daemon

Starting it is then done using:

doas rc-service nix-daemon start

Groups

Next step is to add your account to the nix-user or nix group depending whether you are on Alpine or Debian respectively.

On Debian this can be done with:

sudo usermod -aG nix-user $USER

And on Alpine this can be done with:

doas addgroup $USER nix

Environment variables

The next step is to set add the Nix binary dir to your PATH. To that end, I have the following in my .profile

# nix
export PATH=$PATH:$HOME/.nix-profile/bin

Now source your .profile again, either using…

source ~/.profile

…or by logging out and back in again.

Adding a channel

Now you have a functioning Nix package manager configuration and all that remains to be done is adding and syncing the repo.

The Alpine package defaults to adding the unstable channel. The Debian package doesn’t add any channels at all by default. This can be verified with:

nix-channel --list

To add the unstable channel to your channels, run the following command:

nix-channel --add https://nixos.org/channels/nixpkgs-unstable

You can probably also add stable channels, but I haven’t tried that, as one of the reasons I want to use the Nix package manager on other distros than NixOS is for it’s newer packages. (I am aware that the stable channel of NixOS is a lot newer than the Debian stable branch, which is precisely why I don’t want to to be my base system on machines where I have Debian installed.)

Syncing channels

To sync your (just added) channel(s), run:

nix-channel --update

From this point on you can query your channel(s) using either the website (which is a lot quicker) or:

nix-env -qa <query>

Packages can be imperatively installed using…

nix-env -iA nixpkgs.<package-name>

…and removed using…

nix-env --uninstall <package-name>

Consult the manual for further usage.

Adblock

Mon, 22 Aug 2022 23:46:09 +0200

UBlock Origin

Before I even get started, I’m going to tell you to use UBlock Origin.

It is by far the most configurable and extensive adblocker that I know of. I use it in every browser that supports it.

Moral Conundrums

You often hear people proclaim that blocking ads is bad for the internet the way that it is. After which they will say that the alternative is to pay for every now-free aspect of the internet. Usually through something like subscriptions.

My response is to this is “Have you seen how popular crowd funding has gotten over the last few years?” People already frequently pay for the content they want to consume. Sure, it might be less than one might get through ad revenue, but that pays off in not having to shill to daddy {Google,Facebook,Apple,Amazon}. This in turn means not indirectly violating your user’s privacy.

But let’s analyse that a bit further. The claim here is that the lack of advertisements would be bad, because it would mean large portions of the internet would become subscription based in some way. For one, I’d argue that the presence of ads on the internet has done more harm than good, going as far as saying that, no, the internet would be better off without ads plastered everywhere. This is never going to happen as there is, understandably a cooperate interest in the internet. And two, not-insignificant portions of the internet already are subscription based.

"By blocking ads you are stealing from creators!"

Sometimes you will even come across people who go as far to genuinely proclaim the preceding. To those people, the only thing I can do is quote the classic “You wouldn’t download a car, would you?” Shortly followed by saying “Yes I fucking would, given the opportunity” No one owes you shit based on the amount of people have ignored the ads on your website.

Then there is also the argument to be made that ads steal one’s attention. The goal here being to manipulate you into buying a product.

Much like with piracy, the you’re not missing out on anything. The only way you would’ve seen any money from it, would be when you’re audience directly sees your content and happens to get an ad shoved in their face. Though I suppose in the case of ads, your audience has no choice but to support you when they don’t use an adblocker. In other words, you are forcing your audience to sacrifice their a part attention to support you, whether they want to or not. In my opinion, this makes it morally wrong to make money off of ads.

I’d argue it is a moral imperative to use an adblocker.

Then there is also the angle of corporations focussing on ads more and more. This in turn means that avoiding an absurd portion of cooperate influence has become hilariously easy; Just install an adblocker that isn’t sponsored by an ad company. The thing is that most people are too lazy to install an adblocker and thus ads are still a viable business model.

Subscription services such as the one that started as a DVD and VHS rental business and the other one with a monopoly over a significant portion of pop culture, have been working towards ad-supported tiers while drastically increasing the price of their paid tiers. It would be pretty funny if these ads could be avoided using UBlock Origin. Personally, I prefer using MPV wherever possible, so I probably won’t find out how well that might work.

Hugo

Thu, 18 Aug 2022 14:53:00 +0200

Reflection

I’ve tried to take a look at Hugo for a few times before properly diving into it.

The first time was back when I first decided to look into making a website not-completely by hand. I had hacked a few previous iterations of this site together and was happy with the design. The next step was to write some blobs of text for people to read besides the random antics that can be found in the side bar.

A few problems arose here. For one, writing directly in HTML is a pain. So I decided to write in markdown and convert that to HTML using Pandoc. From there, I still had to index every page completely by hand. The prospect of this annoyed me quite a bit, so I decided to take a cursory glance at Hugo.

The quick start guide showed how to take a pre-existing theme, a bunch of markdown files and turn that into website. Never having been one to use other people’s work as-is, I quickly gave up when I saw the structure of the themes and couldn’t be bothered to give it a proper shot. This also gave me the impression of it being a Wordpress-esque environment that works great as long as you stick within the standards.

A bit later I found out that Pandoc supports templates. So I tried my hand at hacking a site generator together based on a Makefile and Pandoc. This worked… somewhat. But I deemed it more trouble than it was worth and never got very far with it.

A few weeks ago, I came across someone mentioning Hugo again and how it was really great. I decided to give it another shot. This time really diving into the structure of the themes and it clicked. A thing that probably helped this time around was that it very quickly became clear to me that the features I had been half arsedly implementing in my Makefile were standard features for Hugo. Another thing that undoubtedly helped being that the philosophy and syntax of Pandoc’s more advanced features are quite similar to Hugo’s.

Disservice to Hugo

One big thing I bump into with Hugo is the fact that most Hugo websites I come across take one template and maybe change the colorscheme. I feel this is a great disservice to the potential that Hugo has to offer in terms of flexibility. Yes, you can have it act similar to Wordpress, but you don’t have to. I was scared off because I assumed would have to use some existing template or get my CSS to work within a Hugo context. The process of which, I assumed, would be mostly having beat Hugo into submission before it would display the things I wanted in the way I wanted.

The beauty of Hugo and ultimately the reason this is now a Hugo site, is it’s flexibility. You wouldn’t be able to tell this is a Hugo site if you don’t dig through the metadata fields in the <head> tag. And I guess that is also kind of the problem with it. Most people visibly using Hugo take some standard template proudly proclaiming that the page we’re presently looking at is generated using it.

And the people who want to use Hugo but don’t care for the pre-existing themes, don’t care to proudly shout to the world that their site is made with it. This is why I got the impressions of Hugo that I did.

In that sense, I’m part of the problem in not showing that Hugo can do pretty much anything you can think of in the realm of static, somewhat blog oriented websites.

Aural Insanity

Wed, 10 Aug 2022 15:09:31 +0200

Bid Farewel to your Sanity

A thing consisting of 4 audio tracks.

The tracks used in this… thing are from the following games:

Track Source	Channel
Don't Starve OST - Ragtime	Center
Blood - The Chanting track	Center
Painkiller - The Carnival level	Left
Blood - The Mall/Elevator music	Right

This is a file dedicated to aural insanity produced every now and then

Sorry mate, your browser doesn't support playing audio files.

Anvil

This is the result of deciding to mess around with LMMS, a distorted Minecraft anvil sound ripped from YouTube and having a friend nearby with knowledge on how to create music (in other words, a musician).

I made an anvil melody of sorts and Vlams added a drum sample loop and a few synthesizers.

Sorry mate, your browser doesn't support playing audio files.

Orca

Some Orca experiments.

plinkinator

Orca source

..................
..nVC.............
..................
5U9..Vn..4U9..Vn..
.*:04C....*:03C...
..................
3U5..Vn...........
..:05C............
..................
3U8..Vn...........
.*:06C............
..................

First result

Sorry mate, your browser doesn't support playing audio files.

Later variant

Sorry mate, your browser doesn't support playing audio files.

Shepard tone

Orca source

.C8C7........
.1.67TABCDEFG
.J.3XG.......
.18T1234567..
...2.........
D1.J.........
*:02G.2......

Climb

Sorry mate, your browser doesn't support playing audio files.

Fall

Same as ‘climb’ but with the note and octave loops reversed. Sorry mate, your browser doesn't support playing audio files.

Browsers

Mon, 04 Apr 2022 02:54:33 +0200

Web Browsers With Vim Bindings

If there’s one thing I like it’s Vim bindings everywhere. Since all Vim browser extentions suck on some level, the remaining choice I have is to use browser with built in vim bindings. To that end, there are technically a few options.

Those being:

These projects are great but all have their problems. Let’s go through them bottom-to-top.

Nyxt

Nyxt is written in Common Lisp, making it very easy to hack on. Supports either QtWebEngine or WebKitGTK. It also appeals more to the Emacs world then the Vim world. Much like Emacs, Nyxt does have the option of Vim bindings, but they feel somewhat half baked. Then there is the problem of what little interface there is not being particularly clear. To be fair, I haven’t really given it a proper shot because it’s configured on Common fucking Lisp. Not being much of an Emacs user, I have little to no interest in learning Lisp to configure a browser.

Vimb

The suckless option.

Uses WebKitGTK.
Is written in C and configured in a vimscript-esque syntax. The thing that turns me off from this browser is it being too suckless. It almost feels like surf with a slightly more accessible way of configuring it through something that isn’t a header file.

Practical reasons that prevent me from using it are the lack of proper ad blocking and tabs. By default, it also uses the number keys for URL hinting instead of the home row. It also has similar performance to suckless’ surf In other words, it takes quite a long time to load pages, especially if they contain a large amount of JavaScript (though you shouldn’t be visiting those pages unless strictly necessary) and rather quickly hogs quite a lot of resources.

Vieb

An Electron based browser.

Say whatever you want about Vimb’s performance, but Vieb makes Google Chrome seem like a well balanced product. I’ve seen it eat 25% of a CPU thread with a single tab containing nothing but the Vieb documentation.

It has a rather pretty interface and could (if the github page is to be believed) be used to interact with other Electron applications like the Discord client as if it were ran natively (don’t quote me on that, I’m too lazy to check and probably wrong).

Qutebrowser

Which brings us here.
Qutebrowser is written and configured in Python; and uses the QtWebEngine. It’s extremely flexible and easy to configure. It has reasonable ad blocking that allows for the addition of blocklists in a plain text file. A problem I have with it are that I can’t choose which JavaScript elements to block and which to allow, like UMatrix. But then I did see plans to add support for Firefox extensions which would solve this problem. Another minor gripe I have is that scrolling through long pages can look a little sluggish.

With these changes and (if it weren’t a gigantic nightmare) Gecko support, it would be the perfect browser for me.

Other Web Browsers

When I need to use a site that requires some JS, but still functions without enabling everything, my choice of browser is either Librewolf or a heavily configured Firefox.

From there I use the following list of extensions to make the web usable:

vim-vixen
uBlockOrigin (Installed by default on Librewolf)
redirector
ToS;DR

Vim

Mon, 21 Mar 2022 01:17:06 +0200

Vim Cheat sheet

This is a little Vim cheat sheet with thing people generally don’t seem to be particularly familiar with when it comes to Vim. This is about Vim, not NeoVim, but I most things with still apply to NeoVim.

Self-explanatory things

These are a few bindings that I don’t feel require an extensive explanation.

binding	action
Z Z	write and quit; equivalent to `:wq`
Z Q	quit; equivalent to `:q!`
:x	write and quit; equivalent to `:wq`
g u	swap characters to lower case
g u u	swap characters to lower case on current line
g U	swap characters to upper case
g U U	swap characters to upper case on current line
g {j,k}	if the current line you’re on spans more then the width of your screen, go down to the portion that’s past the linebreak
~	toggle case
z g	add word to current dictionary
[ s	highlight previous misspelled word
] s	highlight next misspelled word
z =	open spelling suggestions based on current dictionary and highlighted word
.	repeat last modify operation
;	repeat last move operation
!	start command with `:<selection>!`

Splits and Terminals

You can split your vim window with somewhat Emacs-like chords by default; I don’t bother changing them because I use with quite a few different computers, not all of which have my Vim dotfiles installed.

binding	action
C-w s	Horizontal split
C-w v	Vertical split
C-w {h,j,k,l}	Move focus to split {left,down,up,right}
C-w S-{h,j,k,l}	Move split to {left,down,up,right}

Another usefull thing I don’t see a lot of people do is open a terminal session in vim. This can be really quite useful if you quickly need to change or check something. You do this with the :terminal command. In Vim, this will horizontally split your current window and open a terminal session in the top half. (Yes, you can also open Vim sessions in these terminal sessions if you feel like it). You can navigate to and from it just like any other splits. In NeoVim terminals are handled significantly worse and is the main reason I went back to base Vim.

Tips

Something I came across some time ago is that you can interpet the current line with whatever you want using

:.!<interpeter>

So for instance running…

:.!bash

…while highlighting the line…

echo Line{1..5} | sed 's/ /\n/g'

…will result in:

Line1
Line2
Line3
Line4
Line5

Configuration

Some settings I like putting in my git configuration files.

set nocompatible
set termguicolors
set cursorline
set hlsearch
set ignorecase
set smartcase
set number
set relativenumber
set wildmenu
set mouse=
set scrolloff=3
set listchars=tab:│\ ,lead:·,trail:·,eol:¬ "'lead' is a NeoVim specific option
set list

" I haven't tried if this works in base vim.
match ExtraWhitespace /\s\+$/
highlight ExtraWhitespace guifg=red

About

Mon, 01 Jan 0001 00:00:00 +0000

The HUMANOID running this thing

Identity - ’s a funny thing isn’t it?

Name: Marty
Date of birth: 18-con-3167
Gender: Not really
Email: marty.wanderer@disroot.org
GPG key
Country: Check the TLD
Gemini
Gitlab - because I evidently can't be arsed to host my own git interface yet...
Mastodon

The site itself

Colorscheme: Gruvbox Depending on prefers-color-scheme: in your browser settings being light or not, you get to see the light variant or not.
This site is viewable and usable on every browser I’ve thrown at it so far.
I even spent a 10 minutes making this site look reasonable on mobile devices.
Here’s the browser list:
- Qutebrowser
- Bromite
- LibreWolf
- FireFox
- UnGoogled Chromium
- Lynx
- Midori
- w3m
- Dillo
- Netsurf
- Nyxt

Software used by $HUMANOID

category	programs
Operating system:	NixOS, Debian, Alpine
Window manager:	XMonad
Graphical browser:	LibreWolf, UnGoogled Chromium, Qutebrowser
Text browser:	Lynx, w3m
Gemini client:	Lagrange, Amfora
Terminal:	Kitty
Text editors:	Vim, NeoVim, VSCodium with NVim plugin
Image viewer:	nsxiv
Video player:	mpv
Music player:	mpd + ncmpcpp

Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

Cheatsheet

This is a collection of random commands that I want store somewhere I wont forget it¹.

ZFS

The ZFS settings you probably want when creating a pool. Shamelessly ripped from another cheatsheet.

sudo zpool create gayms mirror /dev/sda /dev/sdb -O compression=lz4 -o ashift=12 -O atime=off -O xattr=sa

Firefox quirks

Re-enable the protocol indicator in the URL bar in Firefox by setting the browser.urlbar.trimURLs flag to false.

Headscale

Creating a user from the CLI

headscale user create <username>

headscale

Random shell stuff

Redirect stderr to stdout

2>&1

The `rsync` flags you’ll want to use

rsync -avPz

For some reason I wouldn’t be able to get myself to keep track of a notes.md file if my life depended on it. ↩︎

Services

Mon, 01 Jan 0001 00:00:00 +0000

These are a few serices I provide to the people who may be interested in them.

SearXNG instance

Since DuckDuckGo decided to censor content a few weeks ago at time of writing, the thought of spinning up another SearX instance started to form in the back of my mind. Then at time of writing, they decided to start to block more content in relation to copyright infringing material. This still doesn’t nessecarily mean too much, but who knows how much they’re going to continue blocking now they’ve started in the first place.

So here’s that SearX instance, enjoy!

I have got to say that the theming of SearXNG has improved quite a lot either over the years or in my mind. At the very least I think the default theme looks quite nice these days.

SearXNG does make use of JavaScript for certain functions, but it's purely to make using it a smoother experiece and it's perfectly functional without JavaScript.

The Voidcruiser

Distortions

Festering Ideas

First Manifestations

Magick

Black Magick

Initial text

With glitch0r

Mangled results with imagemagick

Conclusion

Config Snippets

Mess

Nix snippets

home-manager color scheme

Qutebrowser

XMonad

Volume control using scroll wheel

Kitty wrappers

Emergent Game Mechanics

Preamble

The Meat and Potatoes

Orca

Brainy Music

Patterns

Numbers and stuff

Recording from LMMS

I2p on NixOS

Introduction

The i2p module

Torrents

Tying it to /etc/nixos/configuration.nix

Browser profile

.desktop entry via home-manager

Using everything

Ideas

XMonad Promtps

Introduction

Bookmarks menu

Implementation

Parsing the Bookmarks file

Creating a Prompt

Keybinding

Everything Together

On window managers and XMonad

My journey into Tiling Window Managers

PWR Switch

Introduction

Setup

Remote interaction

Hosting your own Git "server"

Introduction

Setting up the server

Adding an account

Setting up SSH

Client side

Server side

Adding a repository

Automation

SSH Configuration

Introduction

Generating keys

Server Configuration

Password Authentication

Adding keys to authorized_keys

Changing the port

Client configuration

The ~/.ssh/config file

AddKeysToAgent

IdentitiesOnly

ProxyCommand

The SSH Agent

Forced Commands

Nix Home Manager

The Home Manager

Actually using Home Manager

Installing packages

Managing dotfiles and configuration

Git configuration

Integrating existing (dot)files

Git integration

`home-manager` color scheme

Tying it to `/etc/nixos/configuration.nix`

`.desktop` entry via `home-manager`

Adding keys to `authorized_keys`

The `~/.ssh/config` file

`AddKeysToAgent`

`IdentitiesOnly`

`ProxyCommand`

The `rsync` flags you’ll want to use