Ralsina.Me

Learning Crystal by Implementing a Static Site Generator

Roberto Alsina — Thu, 01 Jun 2023 01:15:30 GMT

What?

A while back (10 YEARS???? WTH.) I wrote a static site generator. I mean, I wrote one that is large and somewhat popular, called Nikola but I also wrote a tiny one called Nicoletta

Why? Because it's a nice little project and it shows the very basics of how to do a whole project.

All it does is:

Find markdown files
Build them
Use templates to generate HTML files
Put those in an output folder

And that's it, that's a SSG.

So, if I wanted a "toy" project to practice new (to me) programming languages, why not rewrite that?

And why not write about how it goes while I do it?

Hence this.

So, what's Crystal?

It's (they say) "A language for humans and computers". In short: a compiled, statically typed language with a ruby flavoured syntax.

And why? Again, why not?

Getting started

I installed it using curl and that got me version 1.8.2 which is the latest at the time of writing this.

You can get your project started by running a command:

nicoletta/crystal
✦ > crystal init app nicoletta .
    create  /home/ralsina/zig/nicoletta/crystal/.gitignore
    create  /home/ralsina/zig/nicoletta/crystal/.editorconfig
    create  /home/ralsina/zig/nicoletta/crystal/LICENSE
    create  /home/ralsina/zig/nicoletta/crystal/README.md
    create  /home/ralsina/zig/nicoletta/crystal/shard.yml
    create  /home/ralsina/zig/nicoletta/crystal/src/nicoletta.cr
    create  /home/ralsina/zig/nicoletta/crystal/spec/spec_helper.cr
    create  /home/ralsina/zig/nicoletta/crystal/spec/nicoletta_spec.cr
Initialized empty Git repository in /home/ralsina/zig/nicoletta/crystal/.git/

Some maybe interesting bits:

It inits a git repo, with a gitignore in it
Sets you up with a MIT license
Creates a reasonable README with nice placeholders
We get a shard.ymlwith metadata
Source code in src/
spec/ seems to be for tests?

Mind you, I still have zero idea about the language :-)

This apparently compiles into a do-nothing program, which is ok. Surprisied to see starship seems to support crystal in the prompt!

crystal on  main [?] is 📦 v0.1.0 via 🔮 v1.8.2 
> crystal build src/nicoletta.cr

crystal on  main [?] is 📦 v0.1.0 via 🔮 v1.8.2 
> ls -l
total 1748
-rw-rw-r-- 1 ralsina ralsina    2085 may 31 18:15 journal.md
-rw-r--r-- 1 ralsina ralsina    1098 may 31 18:08 LICENSE
-rwxrwxr-x 1 ralsina ralsina 1762896 may 31 18:15 nicoletta*
-rw-r--r-- 1 ralsina ralsina     604 may 31 18:08 README.md
-rw-r--r-- 1 ralsina ralsina     167 may 31 18:08 shard.yml
drwxrwxr-x 2 ralsina ralsina    4096 may 31 18:08 spec/
drwxrwxr-x 2 ralsina ralsina    4096 may 31 18:08 src/

Perhaps a bit surprising that the do-nothing binary is 1.7MB tho (1.2MB stripped) but it's just 380KB in "release mode" which is nice.

Learning a Bit of Crystal

At this point I will stop and learn some syntax:

How to declare a variable / a literal / a constant
How to do an if / loop
How to define / call a function

Because you know, one has to know at least that much 😁

There seems to be a decent set of tutorials at this level. let's see how it looks.

Good thing: this is valid Crystal:

module Nicoletta
  VERSION = "0.1.0"

  😀 = "Hello world"
  puts 😀 
end

Also nice that variables can change type.

Having the docs say integers are int32 and anything else is "for special use cases" is not great. int32 is small.

Also not a huge fan of separate unsigned types.

I hate the "spaceship operator" <==> which "compares its operands and returns a value that is either zero (both operands are equal), a positive value (the first operand is bigger), or a negative value (the second operand is bigger)" ... hate it.

Numbers have named methods, which is nice. However it randomly shows some weird syntax that has not been seen before. One of these is not like the others:

p! -5.abs,   # absolute value
  4.3.round, # round to nearest integer
  5.even?,   # odd/even check
  10.gcd(16) # greatest common divisor

Or maybe the ? is just part of the method name? Who knows! Not me!

Nice string interpolation thingie.

name = "Crystal"
puts "Hello #{name}"

Why would anyone add an underscore method to strings? That's just weird.

Slices are reasonable, whatever[x..y] uses negative indexes for "from the right".

We have truthy values, 0 is truthy, only nil, false and null pointers are falsy. Ok.

I strongly dislike using unless as a keyword instead of if with a negated condition. I consider that to be keyword proliferation and cutesy.

Methods support overloading. Ok.

Ok, I know just enough Crystal to be slightly dangerous. Those feel like good tutorials. Short, to the point, give you enough rope to ... make something with rope, or whatever.

Learning a Bit More Crystal

So: errors? Classes? Blocks? How?

Classes are pretty straightforward ... apparently they are a bit frowned upon for performance reasons because they are heap allocated, but whatevs.

Inheritance with method overloading is not my cup of tea but 🤷

Exceptions are pretty simple but begin / rescue / else / ensure / end? Eek.

Also, I find that variables have nil type in the ensure block confusing.

Requiring files is not going to be a problem.

Blocks are interesting but I am not going to try to use them yet.

Dinner Break

I will grab dinner, and then try to implement Nicoletta, somehow. I'll probably fail 😅

Implementing Nicoletta

The code for nicoletta is not long so this should be a piece of cake.

No need to have a main in Crystal. Things just are executed.

First, I need a way to read the configuration. It looks like this:

TITLE: "Nicoletta Test Blog"

That is technically YAML so surely there is a crystal thing to read it. In fact, it's in the standard library! This fragment works:

require "yaml"

VERSION = "0.1.0"

tpl_data = File.open("conf") do |file|
  YAML.parse(file)
end
p! tpl_data

And when executed does this, which is correct:

crystal on  main [!?] is 📦 v0.1.0 via 🔮 v1.8.2 
> crystal run src/nicoletta.cr
tpl_data # => {"TITLE" => "Nicoletta Test Blog"}

Looks like what I want to store this sort of data is a Hash

Next step: read templates and put them in a hash indexed by path.

Templates are files in templates/ which look like this:

<h2><a href="${link}">${title}</a></h2>
date: ${date}
<hr>
${text}

Of course the syntax will probably have to change, but for now I don't care.

To find all files in templates I can apparently use Dir.glob

And I swear I wrote this almost in the first attempt:

# Load templates
templates = {} of String => String
Dir.glob("templates/*.tmpl").each do |path|
  templates[path] = File.read(path)
end

Next is iterating over all files in posts/ (which are meant to be markdown with YAML metadata on top) and do things with them.

Iterating them is the same as before (hey, this is nice)

Dir.glob("posts/*.md").each do |path|
  # Stuff
end

But I will need a Post class and so on, so...

Here is a Post class that is initialized by a path, parses metadata and keeps the text.

class Post
  def initialize(path)
    contents = File.read(path)
    metadata, @text = contents.split("\n\n", 2)
    @metadata = YAML.parse(metadata)
  end
  @metadata : YAML::Any
  @text : String
end

Next step is to give that class a method to parse the markdown and convert it to HTML.

I am not implementing that so I googled for a Crystal markdown implementation and found markd which is sadly abandoned but looks ok.

Using it is surprisingly painless thanks to Crystal's shards dependency manager. First, I added it to shard.yml:

dependencies:
  markd:
   github: icyleaf/markd

Ran shards install:

crystal on  main [!+?] is 📦 v0.1.0 via 🔮 v1.8.2 
> shards install
Resolving dependencies
Fetching https://github.com/icyleaf/markd.git
Installing markd (0.5.0)
Writing shard.lock

Then added a require "markd", slapped this code in the Post class and that's it:

  def html
    Markd.to_html(@text)
  end

Here is the code to parse all the posts and hold them in an array:

posts = [] of Post

Dir.glob("posts/*.md").each do |path|
  posts << Post.new(path)
end

Now I need a Crystal implementation of some template language, something like handlebars, I don't need much!

The standard library has a template language called ECR which is pretty nice but it's compile-time and I need this to be done in runtime. So googled and found ... Kilt

I will use the crustache variant, which implements the Mustache standard.

Again, added the dependency to shard.yml and ran shards install:

dependencies:
  markd:
   github: icyleaf/markd
  crustache:
   github: MakeNowJust/crustache

After some refactoring of template code, the template loader now looks like this:

class Template
  @text : String
  @compiled : Crustache::Syntax::Template

  def initialize(path)
    @text = File.read(path)
    @compiled = Crustache.parse(@text)
  end
end

# Load templates
templates = {} of String => Template

Dir.glob("templates/*.tmpl").each do |path|
  templates[path] = Template.new(path)
end

I changed the templates from whatever they were before to mustache:

<h2><a href="{{link}}">{{title}}</a></h2>
date: {{date}}
<hr>
{{text}}

I can now implement Post.render... except that top-level variables like templates are not accessible from inside classes and that messes up my code, so it needs refactoring. So.

This sure as hell is not idiomatic Crystal, but bear with me, I am a beginner here.

This scans for all posts, then prints them rendered with the post.tmpl template:

class Post
  @metadata = {} of YAML::Any => YAML::Any
  @text : String
  @link : String
  @html : String

  def initialize(path)
    contents = File.read(path)
    metadata, @text = contents.split("\n\n", 2)
    @metadata = YAML.parse(metadata).as_h
    @link = path.split("/")[-1][0..-4] + ".html"
    @html = Markd.to_html(@text)
  end

  def render(template)
    Crustache.render template.@compiled, @metadata.merge({"link" => @link, "text" => @html})
  end
end

posts = [] of Post

Dir.glob("posts/*.md").each do |path|
  posts << Post.new(path)
  p! p.render templates["templates/post.tmpl"]
end

Believe it or not, this is almost done. Now I need to make it output that (passed through another template) into the right path in a output/ folder.

This almost works:

Dir.glob("posts/*.md").each do |path|
  post = Post.new(path)
  rendered_post = post.render templates["templates/post.tmpl"]
  rendered_page = Crustache.render(templates["templates/page.tmpl"].@compiled,
    tpl_data.merge({
      "content" => rendered_post,
    }))
  File.open("output/#{post.@link}", "w") do |io|
    io.puts rendered_page
  end
end

For some reason all my HTML is escaped, I think that's the template engine trying to be safe 😤

Turns out I had to use TRIPLE handlebars to print unescaped HTML, so after a small fix in the templates...

So, success! It has been fun, and I quite like the language!

I published it at my git server but here's the full source code, all 60 lines of it:

# Nicoletta, a minimal static site generator.

require "yaml"
require "markd"
require "crustache"

VERSION = "0.1.0"

# Load config file
tpl_data = File.open("conf") do |file|
  YAML.parse(file).as_h
end

class Template
  @text : String
  @compiled : Crustache::Syntax::Template

  def initialize(path)
    @text = File.read(path)
    @compiled = Crustache.parse(@text)
  end
end

# Load templates
templates = {} of String => Template

Dir.glob("templates/*.tmpl").each do |path|
  templates[path] = Template.new(path)
end

class Post
  @metadata = {} of YAML::Any => YAML::Any
  @text : String
  @link : String
  @html : String

  def initialize(path)
    contents = File.read(path)
    metadata, @text = contents.split("\n\n", 2)
    @metadata = YAML.parse(metadata).as_h
    @link = path.split("/")[-1][0..-4] + ".html"
    @html = Markd.to_html(@text)
  end

  def render(template)
    Crustache.render template.@compiled, @metadata.merge({"link" => @link, "text" => @html})
  end
end

Dir.glob("posts/*.md").each do |path|
  post = Post.new(path)
  rendered_post = post.render templates["templates/post.tmpl"]
  rendered_page = Crustache.render(templates["templates/page.tmpl"].@compiled,
    tpl_data.merge({
      "content" => rendered_post,
    }))
  File.open("output/#{post.@link}", "w") do |io|
    io.puts rendered_page
  end
end

Keeper of Enchanted Rooms (Whimbrel House, #1)

Roberto Alsina — Wed, 31 May 2023 20:35:10 GMT

Author: Charlie N. Holmberg
Rating: ★ ★ ★
See in goodreads

Review:

Fun story. While it's about magic and it has a sort of magic system it feels more like a late 19th century novel of manners, with just some minor magical elements in it.

If you like that kind of thing, then this is your kind of thing?

Agent of the Terran Empire (Flandry, #3)

Roberto Alsina — Fri, 19 May 2023 17:19:11 GMT

Author: Poul Anderson
Rating: ★ ★
See in goodreads

Review:

I had fond memories of reading Anderson and other classic SciFi of the same vintage when I was a kid.

Well, that seems to be the right age. On one hand, a kid is apt to be carried away by the adventure, which is fun, while also ignoring the misoginy, the casual chauvinism, the jingoism, the general metaphorical racism and a whole lot of other isms and inys which, as a grown up, really dull the enjoyment of the experience.

New minisite: book covers

Roberto Alsina — Tue, 16 May 2023 15:55:21 GMT

Since I wrote tapita to automatically create book covers, it was absurdly easy to turn it into a site where you can create book covers.

So, you can go to Covers.ralsina.me and create book covers.

Fun part: this is the whole backend for the site:

from json import loads
from tapita import Cover
from io import BytesIO
import base64


def handle(req):
    """handle a request to the function
    Args:
        req (str): request body

    {
        "title": "foo",
        "subtitle": "bar",
        "author": "bat",
    }
    """
    try:
        args = loads(req)
    except Exception:
        return "Bad Request", 400

    c = Cover(**args)
    byte_arr = BytesIO()
    c.image.save(byte_arr, format="JPEG")

    return (
        f'<img src="data:image/jpeg;base64, {base64.b64encode(byte_arr.getvalue()).decode("utf-8")}">',
        200,
        {"Content-Type": "text/html"},

New project: Tapita

Roberto Alsina — Tue, 16 May 2023 00:44:18 GMT

For reasons I won't discuss, I needed to create a bunch of ebook covers. Looking around I found some code to do it programmatically, so I adapted/rewrote it and now published my version.

More information at the tapita github repo

And here's an example cover:

It does enough for what I need, but happy to work a bit more on it if anyone wants it.

Home Server Update May 2023

Roberto Alsina — Mon, 15 May 2023 16:02:50 GMT

This is a longer-term update on the state of my home server. You can read more about it in these 1 2 3 4 5 6 posts.

Hardware

Got some SSDs for cheap, so migrated it from HDDs to SDDs. Thanks to btrfs, I could even do that without turning the thing off.
Did some experiments to measure power usage. It's around 8W when it goes full throttle with heavy disk usage.
Working on implementing a UPS for the whole system.

Software

Since the last update I have added a few new services:

Filebrowser

I added a web-based filebrowser. It's ... Filebrowser

Why? Because sometimes I need to manage some files. No big deal, almost never use it.

Ebook Server

It's Kavita and it's pretty good, if a little too basic. I use it to manage an epub collection, and it works. Writing scripts to automatically tag and add metadata to random crappy ebooks was fun.

Snips

A snippet/pastebin thing called snips.sh and it's really nice. I added a small shell script so I can just pipe things to it. I am making the HTTPS public at snips.ralsina.me and keeping the SSH private in my VPN thank you very much.

Had some trouble making it work on ARM because of a tensorflow dependency, but it's running fine.

WatchTower

Watchtower is a tool that monitors your running containers and will daily check if there are new versions. If there are, it will upgrade them. Nice to have things update unattended.

Conclusion

Server is stable

Columbus Was A Dope

Roberto Alsina — Thu, 11 May 2023 16:47:47 GMT

Author: Robert A. Heinlein
Rating: ★ ★ ★ ★
See in goodreads

Review:

Not going to make this long, since it's just a short story, but it's a nice combination of really outdated writing and an ear for a kind of dialog that no human ever used :-)

Brute Force

Roberto Alsina — Mon, 08 May 2023 00:19:05 GMT

Author: Scott Meyer
Rating: ★ ★ ★
See in goodreads

Review:

Not bad, actually!

Better than the latest books I read from the author. Interesting setup, dialog only marginally cringe.

Fulfilling the word quota.

Color Coordination Using Base16

Roberto Alsina — Thu, 04 May 2023 15:18:17 GMT

The Problem

A few days ago I wrote about how I moved from a all-inclusive environment (KDE Plasma) to Qtile, a tiling window manager, and all the things I did to have the amenities I missed from Plasma.

One thing there that may need further explanation is the section about color schemes because the concepts themselves are fairly unusual.

So, let's dig into it a bit more.

This is how a few apps look by default if you don't configure things:

One is a Qt app, and the other is a GTK app and they look ... bad?

I mean, I don't really care all that much, but not only are the widget styles totally different, but the colors are all over the place.

And the same happens to Qtile's bar, and my terminal (alacritty) and my tmuxer (zellij) and my web browser and so on.

Everything is a different color.

In Plasma, a comon color scheme is enforced on most apps (not in chrome, though) and it makes things much nicer.

So, what's the equivalent in the Window Manager world? There isn't one, really, but there are bits and pieces you can make into ... 80% of it.

Here's what I did.

My Solution

First, you need a source of consistent color schemes. If you just really, really, really like a single one, then they may have a site full of configurations for different apps to force them to follow it.

For example: Dracula or Nord

But I wanted to be able to try a bunch and see which one I liked.

For this, there is nothing like base16

Base16 defines a standard. You will have 16 colors. Those colors mean things.

Color 0 is the background.
Color 1 is the foreground.

And so on.

Then it defines some other things, like "If you are doing a 'dark' scheme, colors go from darker to lighter" and so on.

Then they provide a collection of themes, which are each 16 colors following those rules.

For example, this is the Brogrammer Theme:

scheme: "Brogrammer"
author: "Vik Ramanujam (http://github.com/piggyslasher)"
base00: "1f1f1f"
base01: "f81118"
base02: "2dc55e"
base03: "ecba0f"
base04: "2a84d2"
base05: "4e5ab7"
base06: "1081d6"
base07: "d6dbe5"
base08: "d6dbe5"
base09: "de352e"
base0A: "1dd361"
base0B: "f3bd09"
base0C: "1081d6"
base0D: "5350b9"
base0E: "0f7ddb"
base0F: "ffffff"

Now, suppose you want an app to follow the "base 16 standard" to see how it looks in Brogrammer style.

All you need to do is take that app's config file and put the right color where it needs it.

So, for example, for the Alacritty terminal:

colors:
  # Default colors
  primary:
    background: '0x1b1918'
    foreground: '0xa8a19f'

  # Colors the cursor will use if `custom_cursor_colors` is true
  cursor:
    text: '0x1b1918'
    cursor: '0xa8a19f'

  # Normal colors
  normal:
    black:   '0x1b1918'
    red:     '0xf22c40'
    green:   '0x7b9726'
    yellow:  '0xc38418'
    blue:    '0x407ee7'
    magenta: '0x6666ea'
    cyan:    '0x3d97b8'
    white:   '0xa8a19f'

Of course editing all the config files every time you want to change your color scheme is a pain.

So the base16 project also collects templates. Those are files that when combined with a theme generate the configuration file for an application.

This is the Alacritty template:

# Base16 {{scheme-name}} - alacritty color config
# {{scheme-author}}
colors:
  # Default colors
  primary:
    background: '0x{{base00-hex}}'
    foreground: '0x{{base05-hex}}'

  # Colors the cursor will use if `custom_cursor_colors` is true
  cursor:
    text: '0x{{base00-hex}}'
    cursor: '0x{{base05-hex}}'

  # Normal colors
  normal:
    black:   '0x{{base00-hex}}'
    red:     '0x{{base08-hex}}'
    green:   '0x{{base0B-hex}}'
    yellow:  '0x{{base0A-hex}}'
    blue:    '0x{{base0D-hex}}'
    magenta: '0x{{base0E-hex}}'
    cyan:    '0x{{base0C-hex}}'
    white:   '0x{{base05-hex}}'

See those bits like {{base05-hex}}? That one gets replaced with your theme's color 5.

But again, using the template for each app you want to theme is boring.

So you need a tool to do that. The one I use is called flavours

What flavours does is:

Get all the base16 color themes
Get all the base16 app config templates
Following a configuration file, generate all the config files you need.
Optionally: run commands so the apps notice their configs have changed.

For example, this is my configuration for Alacritty:

[[items]]
file = "~/.config/alacritty/alacritty.yml"
template = "alacritty"
subtemplate = "default-256"
rewrite = false

It says:

Generate ~/.config/alacritty/alacritty.yml
Use the alacritty template
From that template use the version called default-256 (don't worry)
DO NOT RECREATE THE WHOLE FILE

That last bit is important. That file doesn't just have the theme, it has a lot of other important stuff, so I don't want it to just have the theme in it.

So, I had to edit it once and put these lines before and after where the theme goes:

# Start flavours
... theme goes here
# End flavours

So when I use flavours to apply a theme it will only replace that bit and leave the rest.

Since alacritty notices when the config has changed, I don't need a hook entry. In other cases you can use it. Here's mine for qtile, to let it know it should reread its config:

hook = "killall -USR1 qtile"

So, I configured this for a bunch of things, and at this point, I can just run something like flavours apply atelier-forest and ...

Yeah, they are not perfect. I still need to tweak some stuff, but it's getting there.

Currently my flavours configuration coordinates these:

Alacritty
Qtile
Zellij
Rofi
Qt
Gtk (using Flatcolor)
VS Code
QuteBrowser

That's roughly every app I use (yes, I am migrating from Chrome to QuteBrowser for no good reason)

And because I am not ok, I wrote a couple of tiny things to make things easier for me.

A rofi-based theme picker called rofi-base16:

And a base 16 template for Zellij.

I also wrote an ugly script to set VS Code's theme but it's shameful, so will not be shown here.

Hopefully this explains something to someone. If it doesn't, well, it will help me when I inevitably forget how this works :-)

Desktop setup

Roberto Alsina — Mon, 01 May 2023 15:18:17 GMT

Introduction

I am a long-term KDE user. How long term? Well, since 1997 or so with intermittencies. A couple of weeks ago, I switched my personal desktops to QTile.

Mandatory screenshot:

Why?

Well, I like to switch things around every few years. I have used Unity, and MATE, and even LxQt at some point, and I have noticed over the years that I don't tend to overlap windows, so tiling window managers are the natural progression of my usage.

For a few years I have used Krohnkite an awesome KWin extension that has really been a pleasure to use and proved me that a tiling WM, with a few reasonable keyboard shortcuts, was a workable solution.

Lately I have been building a homebrew laptop which has fairly limited hardware, but I want to use for real. So I also wanted to explore ways to lower resource usage.

Other related concerns:

I have very dynamic monitor configurations. My computers gain and lose monitor all the time, and this needs to be handled automatically.
I have multiple computers (work, home, homebrew) and they all have very different setups and configurations, but I want them all to work the same.
I use chezmoi to manage my configurations so I want config to be simple text files I can store with a minimum of templating.
I want comfort. I want disk automouning, volume keys, bluetooth menus, wifi configuration, a clock, battery information, notifications and so on.

But why QTile specifically:

It's tiling but with a nice attitude. The whole "hardcore" thing in both tiling WM users and projects is a bit tiresome.
It's written, configurable and extendable in Python, which I like.
It works reasonably out of the box. No, a black screen where you can do nothing without looking up shortcuts in your phone at first is too much.
It's "dynamic". This is one of those minute subcategories you can see in WM fandom, but basically: windows get placed more or less correctly by default, while other WMs will make you explicitly handle each window as it appears, which sounds sort of like torture to me.

So what?

So I will now describe painstakingly every decision I made as of today, and describe the important configuration, and bore anyone who tries to read this to tears, that's what.

In an attempt to make this a bit less annoying I will setup a problem, then describe the solution I found.

Uniform UI for utilities

The Problem

There are a number of ways you interact with your "desktop". You may want to logout. Or start an app. Or run a command. Or configure a bluetooth speaker. Or see the clipboard history. Or configure wifi.

In the desktop world, this all comes included in the package deal. In the Window Manager universe, you have to roll your own, and most setups end with a disparate collection of utilities, like blueman and network-manager and clipit and so on plus whatever the WM itself provides.

Well, but what if they could be the same thing?

What if in addition they could all share a lovely, customizable UI?

The Solution

Enter rofi

the most common usage for rofi is as an app launcher, and it's great at that, but it's just scratching the surface:

Because of its flexible architecture, it can be used to configure your network using networkmanager-dmenu:

As your power/logout menu via rofi-power-menu

And much more. I also use it as a fronted to a pasword manager, a frontend to ssh, a simple Todo list, an emoji picker, as a fancy window switcher, and as a clipboard history manager using rofi-greenclip

Rofi starts so fast that it's often imposible to notice the difference between having a tool always running and with an icon in the systray and just having a button that launches rofi.

So, how do I use it in my ~/.config/qtile/config.py?

Bound to some key shortcuts:

keys = [
    # Launch things
    Key([mod], 'p', lazy.spawn('rofi -show drun'), desc="Run app"),
    Key([mod, "shift"], 'p', lazy.spawn('rofi -show run'), desc="Run Command"),
    Key([mod], 's', lazy.spawn('rofi -show ssh'), desc="Ssh"),
    Key([mod], 'e', lazy.spawn('rofi -show emoji'), desc="Emoji"),
    Key([mod], 'v', lazy.spawn('rofi -modi "clipboard:greenclip print" -show'), desc="Clipboard")
    Key([mod, alt], "Tab", lazy.spawn('rofi -show window'), desc="Move focus to next window"),

I also added a LaunchBar widget to my QTile bar where it replaces something like clipit, the blueman applet, a password manager and a todo app:

    widget.LaunchBar(padding=0, text_only=True, font="Font Awesome 6 Free", fontsize=16, foreground="2e3440", progs=[
        ("", "rofi-bluetooth", "Bluetooth"),
        ("", "rofi -modi 'clipboard:greenclip print' -show", "Clipboard History"),
        ("", "rofi-pass", "Passwords"),
        ("", "rofi-todo -f /home/ralsina/todo.txt", "Todo"),
        ("", "flameshot gui", "Screenshot"),
    ]),

The first field that probably looks like a square in there are unicode characters displayed on the desktop using font awesome:

Also for mouse interactions with the Wlan widget:

widget.Wlan(format=" {percent:2.0%}",width=54, mouse_callbacks={'Button1': lazy.spawn('networkmanager_dmenu')}),

I even use it to show me the shortcut list in case I forgot any!

I could write some minor code and use it for other things too. Rofi is a magnificent example of a tool with a nice API that you can leverage to make it do many different things.

Display Configuration

The Problem

My display configurations are many. I use notebooks, so they all have one "default" configuration where they use their own screen.

In one case, it's all it can use.

In another, it's permanently docked to a monitor above its screen, but sometimes I close the notebook and the only display is the monitor.

In another it's usually docked to a monitor besides its screen, but it's shared with my work computer, so it loses and recovers that monitor dozens of times via a HDMI switch through the day as I switch tasks.

While QTile handles gracefully the addition and removal of displays in general, there are some issues.

Using the HDMI switch didn't make the monitor "go away" which caused some issues with barrier
The config file describes the "bars" for each screen. So I need to put the main bar that has the systray on a screen that is always on. But the screens are one per-output and in a machine-dependent order, and things got complicated really quick. Here Plasma does the right thing effortlessly.

The Solution

Enter autorandr an awesome tool that will react to changes in your situation and do the right thing.

How?

Set your machine as you normally use it say, with two monitors using arandr or something. Then autorandr -s two-monitors
Set your machine in its alternate config, say, with the lid closed. Then autorandr -s closed-lid
Put autorandr -c in your ~.xprofile

This is enough for most things, except the bar situation in QTile.

For that, I wrote two things. First a shell script that goes in ~/.config/autorandr/postswitch This is a "hook" that gets executed after the display configuration changes. Here's mine:

#!/bin/bash -x

config="$AUTORANDR_CURRENT_PROFILE"
notify-send "Switched to config $AUTORANDR_CURRENT_PROFILE"
killall -USR1 qtile  # Make qtile reread configuration

And why do I want qtile to reread its configuration? Because I want the systray to be on the "last" screen, which is always larger :-)

Here's the relevant fragment from ~/.config/qtile/conf.py

screen_count = len(subprocess.check_output(shlex.split("xrandr --listmonitors")).splitlines()) -1

screens = [
    Screen(
        bottom=bar.Bar(
            [ ... # List of widgets for this bar
            # Add systray in the LAST screen, otherwise invisible widget
            widget.Systray(padding=10) if i==screen_count-1 else widget.Sep(linewidth=0),),
    ) for i in range(screen_count)]

This solution requires a minimum of setup for my standards (just configure your screens once and a bit of code) and a maximum of benefit:

The same config works on all my machines, except for autorandr profiles, which have to be done on each computer
It works in a totally automated manner, I never need to move screens around
It will work on any future computers thank to chezmoi

Chrome hates WMs

The Problem

I have seen it a few times in the past. I change WMs or desktops and suddenly chrome has no idea where my passwords went. They are there in passwords.google.com but chrome never autofills, and they are not listed in my local profile.

The Solution

Make sure you are running gnome-keyring-daemon and add this in ~/.config/chrome-flags.conf

--password-store=gnome

The Other Solution

You want a password store that is not chrome. I have one in addition of chrome, using pass

This keeps my passwords encrypted in Git (you can use GitHub, I use my personal gitea) and you can access them from the command line, from a Chrome extension, or from a button in my desktop bar using rofi-pass

This ensures I never will lose access to my passwords, and maximizes the ways I can get to them while keeping things nice and secure.

Automounting Devices

The Problem

While I know perfectly well how to mount devices in Linux, I'd rather they mount themselves.

The Solution

Use udiskie it's lightweight, nicely integrated, and it just works well by default.

Notifications

The Problem

I want desktop notifications.

The solution

Use dunst it's lightweight, nicely integrated, and it just works well by default.

Screen Locking

The Problem

I want my screen to lock, but don't want anything fancy.

The Solution

Use xss-lock and slock

While slock in itself works great, xss-lock integrates it with loginctl so it works better. Just add this to your ~/.xprofile:

xss-lock slock &

Pretty Icons and Colors

The Problem

I want simple icons that are not very colorful, so they integrate with whatever color scheme I am using.

The Solution

Since I am following more or less a nord color scheme I am using a combination of Nordzy icons and just using font-awesome

Here are some snippets from the qtile config. Where I am pointing icons to a specific folder, that folder contains copies of nordzy icons converted to PNG with transparent backgrounds:

bottom=bar.Bar(
    [ ...
        widget.GroupBox(highlight_method="block", foreground="2e3440", active="d08770", inactive="4c566a", this_current_screen_border="242831",this_screen_border="88c0d0"),
        widget.BatteryIcon(theme_path="/home/ralsina/.config/qtile/battery_icons", background="d8dee9", mouse_callbacks=power_callbacks),
        
        widget.Volume(fmt="",padding=0, theme_path="/home/ralsina/.config/qtile/battery_icons"),
        
        widget.LaunchBar(padding=0, text_only=True, font="Font Awesome 6 Free", fontsize=16, foreground="2e3440", progs=[
                    ("", "rofi-bluetooth", "Bluetooth"),
                    ("", "rofi -modi 'clipboard:greenclip print' -show", "Clipboard History"),
                    ("", "rofi-pass", "Passwords"),
                    ("", "rofi-todo -f /home/ralsina/todo.txt", "Todo"),
                    ("", "flameshot gui", "Screenshot"),
                ]),
    ],
    background=["d8dee9"],
    border_width=[1, 0, 0, 0],  # Draw top and bottom borders
    border_color=["b48ead","b48ead","b48ead","b48ead" ],  # Borders are magenta

Then I configured styles and icons for gtk apps (using lxappearance) and Qt apps (using qt5ct) and things now look decent.

Color Schemes

The Problem

I want a coordinated color scheme in the disparate tools I am using.

The Solution

Update: I wrote a more tutorial-like thing about this called Color Coordination Using Base16

Enter flavours, a tool to generate configurations for different things out of simple templates and predefined color schemes.

It already supported my terminal (alacritty) and rofi, just needed to create templates for my qtile config:

colors = {
    "background": "#{{base00-hex}}",
    "background-lighter": "#{{base01-hex}}",
    "selection-background": "#{{base02-hex}}",
    "comments": "#{{base03-hex}}",
    "foreground-dark": "#{{base04-hex}}",
    "foreground": "#{{base05-hex}}",
    "foreground-light": "#{{base06-hex}}",
    "background-light": "#{{base07-hex}}",
    "variables": "#{{base08-hex}}",
    "integers": "#{{base09-hex}}",
    "bold": "#{{base0A-hex}}",
    "strings": "#{{base0B-hex}}",
    "quotes": "#{{base0C-hex}}",
    "headings": "#{{base0D-hex}}",
    "italic": "#{{base0E-hex}}",
    "tags": "#{{base0F-hex}}",
}

And my tmuxer (zellij):

themes {
    default {
        fg "#{{base05-hex}}"
        bg "#{{base00-hex}}"
        black "#{{base00-hex}}"
        red "#{{base08-hex}}"
        green "#{{base0B-hex}}"
        yellow "#{{base0A-hex}}"
        blue "#{{base0D-hex}}"
        magenta "#{{base0E-hex}}"
        cyan "#{{base0C-hex}}"
        white "#{{base05-hex}}"
        orange "#{{base09-hex}}"
    }
}

And put the right incantations in the flavours config (partial):

[[items]]
file = "~/.config/qtile/colors.py"
template = "ralsina"
subtemplate = "qtile"
rewrite = true
hook = "killall -USR1 qtile"

[[items]]
file = "~/.config/zellij/themes/default.kdl"
template = "ralsina"
subtemplate = "zellij"
rewrite = true

I will have to configure everything I want to follow my colour scheme but I can apply it to everything with a simple command like flavours apply monokai

As an extra, here's a script that lets you choose the color scheme using rofi:

#!/bin/sh

LAST_SCHEME=$(cat ~/.local/share/flavours/lastscheme)
SELECTED=$(flavours list | sed 's/\s/\n/g' | grep -n $LAST_SCHEME | cut -d: -f1)

flavours apply $(flavours list| sed 's/\s/\n/g' | rofi -dmenu -selected-row $SELECTED)

Conclusion

What can I say, I like it, it's not ugly, has all the functionality I wanted and uses around 400MB of RAM before I start chrome. I am quite enjoying it.

While this site (intentionally) has no comments, feel free to discuss this in Reddit