Author Archives:Lorenzo Bettini

About Lorenzo Bettini

Lorenzo Bettini is an Associate Professor in Computer Science at the Dipartimento di Statistica, Informatica, Applicazioni "Giuseppe Parenti", Università di Firenze, Italy. Previously, he was a researcher in Computer Science at Dipartimento di Informatica, Università di Torino, Italy. He has a Masters Degree summa cum laude in Computer Science (Università di Firenze) and a PhD in "Logics and Theoretical Computer Science" (Università di Siena). His research interests cover design, theory, and the implementation of statically typed programming languages and Domain Specific Languages. He is also the author of about 90 research papers published in international conferences and international journals.

Running GUI Applications and Tests with Xvfb on KDE Wayland

On Linux,xvfb-runis a convenient way to run graphical applications and UI tests without displaying their windows on the desktop.

However, when usingKDE Plasma with Wayland(for example, on Arch Linux), you might notice that commands such as:

or Maven-based Eclipse SWT UI tests executed withxvfb-runstill show their windows on your desktop!

Why does this happen?

The problem is thatxvfb-rundoes not automatically force applications to use X11 instead of Wayland.

It starts a virtual X server and sets theDISPLAYenvironment variable accordingly. However, it leavesWAYLAND_DISPLAYunchanged.

Applications that prefer native Wayland can therefore bypass Xvfb and connect directly to your actual desktop.

The solution

ForGTK applications, including Eclipse SWT UI tests, force the X11 backend:

ForQt applications, such as Dolphin, useQT_QPA_PLATFORM=xcb:

Dolphin might also communicate with an existing instance through D-Bus, opening a window on your real desktop. To avoid this, use an isolated D-Bus session:

A reusable shell function

Instead of repeating these environment variables, add the following function to your.bashrcor.zshrc:

Now you can simply run:

or:

Conclusion

When running GUI applications or automated UI tests under KDE Wayland, remember thatxvfb-runalone might not be sufficient.

The key is toexplicitly select the X11 backendusingGDK_BACKEND=x11for GTK/SWT orQT_QPA_PLATFORM=xcbfor Qt, while removing the Wayland environment variables.

This allows GUI tests to run on a virtual display without interfering with your regular Wayland desktop session.

Fedora Silverblue: the packages I layer

Layering packages in Fedora Silverblue is not strictly forbidden, but it should be considered the last resort.

For example, I prefer to layer the ZSH shell:

Note that you must reboot when you layer packages.

Quoting from the documentation:

Using package layering creates a new deployment, or bootable filesystem root. It does not affect your current root. This preserves rollback and the transactional model, but means that the system must be rebooted after a package has been layered or updated. You can alternatively use rpm-ostree install --apply-live <package-name> to also temporarily apply the change directly to your currently booted deployment. It’s generally expected that you use package layering sparingly, and use Flatpak and Toolbx whenever possible.

After rebooting, we can verify that ZSH is correctly installed and it’s also reported as part of the current image:

Here I show the packages I layer.

Before that, I need to add external repositories for:

  • Visual Studio Code, because the flatpak version is too sandboxed and I’m not willing to spend time on further configuration without further benefits
  • Dropbox, because the flatpak version breaks now and then (actually, too often for my taste)

And then I run

In particular,

  • gccis required fortree-sitter-cliandneoviminstallation via Homebrew.
  • the two gnome applications are not available as flatpaks
  • I prefer having the JDK (my most used application being Java, my main programming language) as a system package, especially to have Eclipse pick it automatically

A first look at Garuda Linux “Temeraire” (260819) (Mokka edition)

I’m reporting on my first experiments with Garuda Linux (Arch-based), the latest release, “Temeraire” (260819), in the Mokka edition. I’m testing that in a virtual machine.

I can anticipate thatI love the aesthetic of this distro, especially in thisMokka edition, which is more sober than the “dragonized” version.

The installation

The installation is rather smooth, especially if you’re used to Calamares-based installers.

Let’s start the installation.

One thing I also noted in the past is that the black font is not easily readable in the combo boxes during the installation dialog. It turns white when selected, then returns to black.

The installer did not detect my location (Italy), which is strange because other Calamares-based installers have never had this issue.

I had to adjust that manually:

Similarly, for the keyboard layout (which I had already configured as Italian in the live environment), I had to set it manually.

Since this is a virtual machine, I go with “Erase disk”, and also enable swap with hibernation. Note that it only supports BTRFS! As expected, it also supports system encryption.

After inserting the user information, we’re ready to start:

Let’s enjoy a few slides during the installation, telling us what Garuda provides.

The installation took only a couple of minutes. I seem to understand that it does not download anything else from the Internet. After all, unlikeEndeavourOSandCachyOS, you have an ISO for each edition (DE or WM).

The installed system

Let’s reboot.

I love the aesthetic look of Garuda from the very beginning 🙂

Note that the setup assistant needs to update the system (as I said above, the installer doesn’t seem to download from the Internet). The time you saved during the installation has to be paid during the update 😉

By the way, Garuda providesChaotic-AUR! (i.e., “Semi-automated binary repository for AUR packages”). One thing I personally haven’t tried yet.

Global menu like in macOS: if you’re not used to that, it’ll take some time. You might get the feeling that applications have no menu bar at all 😉

Similarly,window controls are on the leftrather than the right (though this can be changed in KDE settings).

We can also see that snapper and automatic snapshots are already configured by looking at the end of the update output:

Pressing ENTER leads us to the Setup Assistant:

I’m not planning to install anything at this stage, but it’s interesting to have such a tool.

Then, we get to the Garuda Toolbox, which also tells us to reboot.

Note that the kernel is “linux-garuda”, which is based on the CachyOS one.

There are many interesting tools in the Garuda Toolbox.

Evenhaving all the configuration files available in one place, ready to edit, is really helpful.

I won’t talk more about the Garuda Toolbox, but it’s a very useful tool! I suggest you explore that.

Let’s see a few other things and configurations.

Krunner is configured to appear in the center of the screen (I like it, though I typically leave it on the top, its default position):

Desktop effects everywhere: blur, wobbly windows, a magic lamp for minimizing a window, cover flow for the task switcher, etc. I love these effects!

Note that the background is blurred when a window is focused.

I’ve already noted the use ofSnapper; the “Snapper Tool” in the dock is not Btrfs Assistant, as I thought, but a simpler one. However, Btrfs Assistant is also installed by default, together with Btrfs maintenance.

Let’s open Konsole, and we get the glorious fastfetch, also telling us that the default shell is fish (I’ll have to try fish someday):

Nice icons, theme, and fonts!

The partitioning, especially from the BTRFS point of view, is the standard one:

It’s nice to havezramconfigured by default as well.

That’s all for the moment!

I’m planning to try to drive Garuda daily.

Have I already said I find it beautiful 😉

Installing CachyOS Linux on a Geekom IT13 Mini PC

In this post, I show how I installedCachyOSLinux (Arch-based) on a Geekcom IT13 Mini PC.

These are the main specs of the Mini PC:

Processors: 16 × 13th Gen Intel® Core™ i7-13620H
Memory: 32 GiB of RAM (31.1 GiB usable)
Graphics Processor: Intel® Graphics

I’m installing CachyOS “cachyos-desktop-linux-260628.iso”; I downloaded the ISO and copied it into myVentoyUSB stick.

The installation procedure

The installation procedure is rather easy and smooth, especially if you’re used to a Calamares-based installer (e.g., the one also used byEndeavourOS).

Before starting the installer from the Welcome dialog, I changed the keyboard layout, using the standard KDE System Settings element:

By the way, the scaling was automatically set to 130%; that’s quite a strange setting (in the past, I was using 125% on this computer). However, everything looks great. The same scaling will persist after installation, and I think I’ll keep it.

Let’s start the installation:

I always preferGRUBas the boot loader.

I prefer to manually partition my installations.

I have Windows on this computer (which I never use, but for the moment I’ll keep it). I had previously created another EFI partition because the one that came with Windows is too small.

So I just need to select it and set the correct mount point: 

Then, I mount additional existing partitions to the mount points I want:

I’m removing the existing Linux distributions I had installed on this computer (EndeavourOS and Arch):

Then, I create the main partition, BTRFS. Note that Calamares allows you to specify that a partition is put at the end of the disk (if I remember correctly, other installers don’t allow you to do that):

When I go on, I get the usual warning about a too-small EFI partition. However, I know there’s enough room, and I go on.

I select KDE Plasma (by the way, CachyOS provides several desktop environments!):

I select the printing support packages, and I keep the default ones.

You might want to have a look at the default packages:

User details as usual:

A final look at the partitioning scheme:

Let’s start and look at a few slides during the installation.

As you might know, CachyOS aims to be a performance-based distro, with optimized compiled packages and kernels. For my computer, it uses the “v3” optimization:

Done!

Let’s restart!

Tweak boot options

Unfortunately, on this mini PC, installing a Linux distribution does not automatically set its GRUB entry as the default. If you had a previous installation, its GRUB will still be used. If, as in this example, you remove previous distributions, you get an error when booting from GRUB because it cannot find anything.

We have to fix it in the UEFI settings: when booting, press F7to access the boot menu.

You see that “cachyos” is the last one.

Let’s select “Enter Setup”:

“Fixed Boot Order Priorities” does not let you change the order, only see it:

We must use “UEFI NVME Drive BBS Priorieties”:

Select the first option:

Select the entry that must become the first option (yes, quite confusing!):

And now we’re done:

Now, we finally get the CachyOS GRUB menu!

Stay tuned for the upcoming blog post on the installed system!

My Favorite New Features in macOS Tahoe

After installing macOS Tahoe, two additions immediately stood out to me: proper battery charge limits and a much more useful Spotlight.

A real battery charge limit—even on my M1 Mac

macOS can now limit charging to80%, 85%, 90%, 95%, or 100%directly from the Battery settings.

I normally use my MacBook connected to power for long periods, so being able to choose an 80% limit should help reduce unnecessary battery aging. I especially appreciate that Apple has made this available even on my older M1 Mac.

When this is set, you can see that charging is paused if above 80%, and you have the option to explicitly charge it to full:

If it’s below 80%, it will charge only up to 80%:

Optimized Battery Charging is still available, so I can either let macOS learn my routine or set a fixed limit myself.

You can also set the “Low Power” mode:

See the battery icon turning yellow when set.

On a MacBook Pro, you also have more choices concerning the Energy Mode:

Spotlight finally has useful filtering shortcuts

Spotlight has also become much more practical. Searches can now be restricted immediately with keyboard shortcuts:

  • ⌘ 1for applications
  • ⌘ 2for files
  • ⌘ 3for actions
  • ⌘ 4for clipboard contents

The/key can be used to filter the current search, while the Up Arrow opens the search history.

This makes Spotlight feel less like a simple application launcher and more like a proper keyboard-driven command center.

Clipboard search is optional, which is sensible given that copied content may contain sensitive information.

These are not necessarily the flashiest changes in macOS Tahoe, but they are exactly the kind of small, practical improvements that make a difference in everyday use.

Installing Maven with chezmoi

I usechezmoito manage my dotfiles, including a few small scripts that install development tools in my home directory.

One of these scripts installs Apache Maven. I keep it as arun_onchange_after_script so that chezmoi runs it only when the script changes. This is especially convenient for versioned tools: when I want to upgrade Maven, I change the version number in the script, and the nextchezmoi applyinstalls the new version.

The script is called:

Here is the complete script.

What this script does

The script installs a specific Maven version into my home directory, without requiring root privileges and without relying on a distribution package manager.

The resulting layout is:

The versioned installation lives under~/.local/opt/apache-maven-<version>, while~/.local/opt/mavenis a stable symbolic link to the currently selected Maven version.

This gives me two useful properties at the same time: I can keep explicit versioned installations, but I can also refer to Maven through a stable path.

Whyrun_onchange_after_

chezmoi treats scripts with names such asrun_onchange_after_20-install-maven.shspecially.

Therun_onchange_part means the script is executed when its contents change. Theafterpart means it runs after chezmoi has applied the rest of the dotfiles.

That is exactly what I want here. Maven does not need to be downloaded on everychezmoi apply. It only needs to be installed when I change something relevant in the script, such as the Maven version.

To upgrade Maven, I change this line:

Then I run:

Since the script content changed, chezmoi runs it again and installs the new Maven version.

Why install under~/.local

I prefer installing this kind of tool under my home directory:

and exposing commands through:

This avoids usingsudo, keeps the installation independent from the operating system package manager, and makes the setup easier to reproduce across machines.

It also avoids interfering with any Maven version installed system-wide. The Maven installed by this script is simply the one that appears first in myPATH.

Downloading from Apache mirrors

The script constructs the Maven download URL based on the configured version. For current Maven releases, it downloads from the main Apache download infrastructure.

There is also a fallback to the Apache archive. This matters because older versions are eventually removed from the main mirrors. Since dotfiles often pin specific versions for a long time, falling back to the archive makes the script more robust.

This is useful when setting up a new machine months later: even if the pinned Maven version is no longer on the primary mirror, the script can still find it in the Apache archive.

Verifying the archive

The script downloads both the Maven archive and the corresponding SHA-512 checksum file.

Before extracting Maven, it computes the local SHA-512 digest of the downloaded archive and compares it with the published checksum. If the two values do not match, the script stops immediately.

The checksum parsing is intentionally tolerant: instead of depending on one exact checksum-file format, the script scans the file for a 128-character hexadecimal token, which corresponds to a SHA-512 digest.

For computing the local checksum, the script supports several common tools:

  • sha512sum
  • shasum
  • openssl

This makes the script usable on different Unix-like systems without assuming one specific checksum command.

Idempotency

The script is safe to run more than once.

If the requested Maven version is already installed and contains an executablemvn, the script does not download or extract it again. It still refreshes the stable symlink and the command links, but it avoids unnecessary network access.

When installation is needed, everything is done first in a temporary directory. The archive is downloaded there, the checksum is verified there, and Maven is extracted there. Only after the extracted archive looks valid is it moved into the final installation directory.

That keeps partially downloaded or invalid archives away from the final destination.

Stable symlinks

The script creates a stable Maven symlink:

pointing to the selected versioned installation:

Then it creates command symlinks in~/.local/bin:

These point through the stable Maven symlink instead of directly to the versioned directory.

That means the command links do not need to change structurally when Maven is upgraded. Themavensymlink changes, andmvnfollows it.

The script is also conservative: it overwrites existing symlinks, but it does not overwrite existing non-symlink files. If a real file or directory already exists where the script wants to create a symlink, the script either keeps it or stops with an error.

PATH handling

At the end, the script checks whether~/.local/binis already inPATH.

If it is not, the script does not automatically modify shell startup files. It simply prints a reminder to add:

I prefer this because installation scripts should not unexpectedly edit shell configuration files. The dotfiles themselves are the right place to managePATH.

Why not use the package manager?

Installing Maven from the system package manager is perfectly fine in many cases.

For my dotfiles, however, I prefer this script because it gives me:

  • a specific upstream Maven version;
  • the same version across different machines;
  • a user-local installation;
  • no dependency on distribution-specific package names;
  • a simple upgrade mechanism through chezmoi;
  • checksum verification before installation.

This approach is not meant to replace the package manager for everything. It is just a good fit for development tools where I care about the exact upstream version.

Final result

After running:

Maven is available as:

and the installation is fully contained under my home directory.

The important paths are:

This keeps the setup explicit, reproducible, and easy to update across machines.

Here’s an example updating the dotfiles on a machine after updating the Maven version:

Happy dotfiles! 😉

Getting Started with LM Studio in Linux

I report my first experiences with LM Studio in (Arch) Linux.

LM Studio is a desktop application that allows you to discover, download, and run Large Language Models (LLMs) entirely on your own computers, offline.

This is the hardware and system I’m testing it (you see, no GPU with VRAM):

First, download the AppImage from the websitehttps://lmstudio.ai/.

Run it, and follow the welcome steps:

It proposes to download the first model, which seems to fit my hardware (Gemma 4 e4b):

Finally, we get to the main interface:

Now, select the model (the only one currently downloaded)

And you can start to chat (in the following, I’m experimenting with creating a Maven project, but I’ll blog about such experiments in the future):

You can configure model parameters and possibly make such a configuration the default for the model:

For example, increase the context length:

Download other models using the UI for searching:

Note how LM Studio tells whether a model fits your hardware or is likely too large:

Alternatively, use the CLI “lms” to download a model:

During the downloading, the GUI also reports that:

Note that models are downloaded by default into “~/.lmstudio/models”:

OK, that’s all for this post!

Stay tuned for experiments with LM Studio and open source models.

Archinstall: dual boot with another Linux installation

In the past, I had several problems usingarchinstallfor installing Arch Linux in a dual boot with another existing Linux installation. In fact, I gave up using archinstall andcreated my own script for installing Arch.

In particular, I experienced these two problems:

  • Archinstall failed installing Arch if the disk already contained a BTRFS partition
  • The “/boot/efi/” mount point could not be used: you had to use “/boot” (since all my other Linux installations use “/boot/efi”, which required a few tweaks that I was not willing to spend time on)

I tried once more with the July 2026 version, and both problems are finally gone (though, for the second one, there are a few things to know, as shown in the rest of this blog post).

Besides experimenting with Archinstall for dual boot with another Linux installation, I’ll also take the chance to quickly review a few parts of the installation procedure.

I experimented with the process on a KVM virtual machine, where I had already installed EndeavourOS, leaving some space for another installation.

Let’s keep an eye on the current state of “/boot/efi” and see later how Archinstall handles it.

And here’s the UEFI entries; the existing EndeavourOS installation is the “UEFI Misc Device”.

Let’s start the installation by booting the Arch Linux July 2026 ISO and running the Archinstall script:

The crucial part is disk partitioning, where we must select “Manual Partitioning”

Select the existing UEFI partition

And assign the “/boot/efi” mount point:

Then, select the empty partition, and create a new BTRFS partition:

Now, the sad part: I’m used to EndeavourOS or other Calamares-based installers that automatically create the default subvolumes when you create a BTRFS partition for the “/” mount point. Instead, in Archinstall, you have to deal with the subvolumes yourself:

Following the same process four times, I created the standard subvolumes (I skipped the ones for “/var/lib/portables” and “machines, which EndeavourOS creates, since I don’t care about them):

This is the final layout:

Now, select GRUB:

Here’s the crucial part: “Install to removable location”, enabled by default. If you press ENTER, you get more details:

The text explains a few things and tells you it is safe to leave it on.

However, if you do leave it on, then Archinstall will overwrite the NVRAM entry for existing Linux installations.

I triedboth options in two different virtual machines; let’s see what happens:

Select NO

With this option, Arch will be the default boot option in the UEFI; however, existing entries can still be selected from the UEFI menu.

So, let’s select NO, and here’s what that entry reports:

Let’s conclude the installation and reboot.

Here’s the GRUB from Arch; let’s enter the UEFI settings

“GRUB” is Arch Linux, and “UEFI Misc Device”, if you look at the beginning of the blog post, is the existing EndeavourOS:

In fact, if we select it and press ENTER, we get to the EndeavourOS GRUB menu:

And here’s how “/boot/efi” has been modified:

Select YES

Let’s instead select YES (as I said, this is a parallel experiment on a different virtual machine, with the same existing EndeavourOS installation).

Of course, we have the Arch GRUB:

And the “/boot/efi/” still has the previously existing EndeaavourOS efi file.

However, if we enter the UEFI settings:

We no longer have an entry for EndeavourOS. This time, “UEFI Misc Device” is the Arch entry, not the EndeavourOS anymore.

However, we can manually re-add the EndeavourOS entry, because its EFI file is still there.

The procedure depends on the UEFI Firmware settings; in this case, we use the settings provided by “Virtual Machine Manager” Tiano Firmware settings:

We have to navigate to the EndeavourOS EFI file:

And now we have the EndeavourOS entry back (this time, with its real name):

Final thoughts

Things have improved, and Archinstall is probably usable for dual-booting now. I’ll try that on real hardware.

However, I still find it’s still far from being as useful as Calamares-based installers of EndeavourOS, CachyOS, or Garuda, to name a few.

Fixing LibreOffice Flatpak Opening Files from GNOME Dash

I use FedoraSilverbluewithGNOME, and I have LibreOffice installed as a Flatpak.

Recently, I hit a strange problem: when searching for an office document from the GNOME Dash — for example, an.odtor.odsfile in my Dropbox folder — and selecting it, LibreOffice appeared to start, but then failed with an error saying that a file like this did not exist:

The confusing part was that the filedidexist at that path.

Even more confusing: if I removed the file from/run/user/1000/doc/..., the original file was removed too.

So what was going on?

The short version

The fix was:

This creates the following user override:

stored in:

After that, opening LibreOffice documents from the GNOME Dash worked again.

The setup

The system is Fedora Silverblue, so applications are mostly Flatpaks. LibreOffice is installed as:

The problematic documents live under Dropbox, for example:

Opening the same files withxdg-openworked fine:

Opening them directly with Flatpak also worked:

So LibreOffice itself was not broken.

The problem only happened when opening documents from theGNOME Dash search results.

The mysterious/run/user/1000/docpath

When GNOME opened the file from the Dash, LibreOffice complained about a path like this:

This is not a normal temporary directory.

It is part of the Flatpak / XDG document portal mechanism. The document portal exposes selected host files to sandboxed applications through a FUSE mount under:

The directory name that looks like a hash is a document portal ID.

In my case:

was the document ID.

The file under/run/user/1000/doc/...was not a copy. It was a portal-backed view of the original file. That explains why deleting it also deleted the original document.

Donotmanually clean this directory withrm.

Inspecting the document portal entry

The useful command was:

It printed:

This confirmed several things:

  1. The/run/user/1000/doc/...path was a document portal path.
  2. The original file was the Dropbox file.
  3. GNOME was not launching the generic LibreOffice app ID.
  4. It was using the Writer-specific ID:

The important part is that GNOME Dash was creating a fresh portal export every time I tried to open a document.

So this was not stale recent-file history, nor was it a broken search index.

Things that did not fix it

I first tried granting LibreOffice access to my whole home directory:

That did not solve the GNOME Dash problem.

This makes sense in hindsight. The issue was not that LibreOffice could not access my Dropbox file directly. Direct opening already worked.

The issue was that GNOME Dash was giving LibreOffice this path:

not this one:

Granting access tohomedoes not automatically make/run/user/1000/docvisible inside the Flatpak sandbox.

I also tried clearing recent files, resetting the GNOME file index, restarting portal services, and logging out and back in.

Still, every time I opened a new LibreOffice document from the Dash, a new directory appeared under:

That was the clue: GNOME was actively creating new document portal exports.

The actual fix

The working fix was to allow the LibreOffice Flatpak to see the document portal runtime directory:

Then kill any running LibreOffice instance:

After that, opening documents from the GNOME Dash worked.

The resulting override file is:

stored at:

This is much better than granting access to the whole home directory.

Why this works

GNOME Dash opens the document through the portal and passes LibreOffice a path like:

But the LibreOffice Flatpak sandbox did not have that runtime directory visible.

By granting:

we expose just the document portal mount inside the sandbox.

That is enough for LibreOffice to resolve the path that GNOME provides.

Keeping the fix in chezmoi

Since I manage my dotfiles with chezmoi, I added this file:

In chezmoi form, that is:

with this content:

That is all I need.

Useful commands

Show current LibreOffice Flatpak overrides:

Inspect a document portal entry:

Grant access to the document portal mount:

Remove the override again:

Kill LibreOffice after changing overrides:

Final result

The minimal override is:

This fixes opening LibreOffice documents from the GNOME Dash without granting LibreOffice access to the whole home directory.

The root cause appears to be this interaction:

LibreOffice was provided with a valid host-side portal path, but the sandbox could not find the corresponding runtime directory.

Grantingxdg-run/docbridges exactly that gap.

Bootstrapping chezmoi_modify_manager before chezmoi apply

If you usechezmoi_modify_managertogether withchezmoi, there is one annoying bootstrap problem:

  • chezmoi_modify_manageris needed whilechezmoi applycomputes file contents
  • but the usual.chezmoiscripts/run_before_*hooks run too late to install it for thefirstapply

I wanted a solution that was:

  • automatic
  • shell-based
  • version-pinned
  • rerun only when the installer script changes

This post shows the setup I ended up with.

The problem

At first glance, it seems natural to put an installer script into.chezmoiscripts, for example, as arun_onchange_before_*script.

That helps with normal lifecycle management, but itdoes notsolve the initial bootstrap.

Why? Becausechezmoineeds to compute the target state before it runs those scripts, andmodify_files participate in that computation. If those files usechezmoi_modify_manager, then the binary must already existbeforechezmoi applyreaches the script phase.

So the core issue is:

chezmoi_modify_managermust be installed beforechezmoi applystarts doing the work that depends on it.

The approach

The solution is to split the problem into two:

  1. Put the installer in.chezmoiscriptsas arun_onchange_before_*script, so the script is tracked bychezmoiand reruns when its contents change.
  2. Wrapchezmoiwith a small shell function that manually runs that installer scriptbeforedelegating to the realchezmoi apply.

That gives us the best of both worlds:

  • properchezmoi-managed script in the source repo
  • successful first bootstrap
  • automatic reinstall when the installer changes, such as when bumping the pinned version

The installer script

I placed this file in:

~/.local/share/chezmoi/.chezmoiscripts/run_onchange_before_00-install-chezmoi-modify-manager.sh

The script is version-pinned, architecture-aware, and idempotent. It also keeps a tiny version stamp, so it can skip work when the correct version is already installed.

A few notes:

  • VERSIONis deliberately hardcoded for simplicity
  • STAMPstores the installed version so the script can cheaply detect whether work is needed
  • --doctorprovides a sanity check after installation

If you later want to upgrade, just change theVERSIONstring in the script. Because the script is arun_onchange_*script,chezmoiwill detect the change.

Manual bootstrapping

After running “chezmoi init <URL>” and before running “chezmoi apply” for the first time, you must remember to manually execute this script

Alternatively, you can use the “wrapper” solution detailed next.

The wrapper

Now for the missing bootstrap step: we need to ensure the installer runsbeforechezmoi apply.

I used a shell function in my~/.bashrc(or~/.zshrc).

Then reload your shell:

With this in place, running:

does the following:

  1. finds the realchezmoi
  2. checks whether the installer script exists in the source directory
  3. runs the installer script first
  4. only then runs the realchezmoi apply

That is exactly what we need.

Why this works

This setup works because it respects the real dependency order.

The dependency is not:

“Run a script sometime before applying files.”

The dependency is:

“Ensurechezmoi_modify_managerexists beforechezmoistarts evaluating anything that depends on it.”

A normalrun_before_*script is still part ofchezmoi’s internal apply pipeline, which is already too late for the very first bootstrap.

The shell wrapper moves the install step out of the pipeline and places it beforechezmoi applybegins.

Why keep the installer in.chezmoiscriptsat all?

Because it still gives you usefulchezmoibehavior:

  • the installer lives in your dotfiles repo
  • it is versioned like everything else
  • changing the script content is part of your normal dotfiles workflow
  • therun_onchange_*naming still reflects the script’s intended lifecycle

In other words, the wrapper solves the bootstrap timing problem, while.chezmoiscriptskeeps the implementation underchezmoi‘s control.

Optional: ensure~/.local/binis on yourPATH

If your shell does not already include~/.local/bin, add it:

 

Happy dotfiles! 🙂

SWTBot Tests Failing on GitHub Actions macOS Because of “Welcome to Mac” (Setup Assistant Analytics)

My SWTBot UI testsrecently started failing on GitHub Actions macOS runners.

The application under test is an Eclipse-based application, so at first I expected the failure to be caused by some SWTBot timing issue, focus issue, or maybe a regression in my own code.

However, the screenshot captured by the failed test showed something completely unrelated to my application:

That is not Eclipse. That is macOS Setup Assistant.

More specifically, it was the macOS Analytics screen asking whether to share analytics data with Apple and app developers. Since SWTBot drives the UI that currently has focus, this dialog was stealing focus from Eclipse and making the test interact with the wrong window.

The first workaround

My first attempt was to dismiss the Analytics dialog before starting the SWTBot tests:

This looked reasonable, but then the failure changed.

The new screenshot showed another Setup Assistant page:

This time it was the “Welcome to Mac” screen.

So the script was managing to click something, but Setup Assistant was still not completely gone. SWTBot was still losing focus before the actual Eclipse application could be tested.

The final workaround

The most robust fix was to avoid heredocs entirely and pass the AppleScript using repeatedosascript -earguments.

Here is the workflow step I now use:

This does three things:

  1. It checks whetherSetup Assistantis running.
  2. It tries to press the visible Continue button.
  3. If Setup Assistant still refuses to disappear, it kills the process before the UI tests start.

After adding this step before launching Eclipse, the SWTBot tests started passing again.

Why this matters for SWTBot

SWTBot tests are particularly sensitive to focus problems.

They do not just test some isolated backend logic. They drive a real UI. If another native macOS window appears in front of the Eclipse workbench, the test can fail in confusing ways:

The actual problem may have nothing to do with SWTBot or Eclipse. The test may simply be interacting with the wrong application.

That is why screenshots from failed UI tests are invaluable. Without the screenshot, I would probably have spent a lot more time debugging Eclipse, SWTBot, or my own application.

Running Homebrew Commands with sudo on Linux and macOS

Sometimes a command installed with Homebrew needs to be executed as root. A good example isnethogs, which needs elevated privileges to inspect network traffic.

The problem is that this often fails:

even though this works:

The reason is thatsudousually runs with a different, restrictedPATH. Your normal shell can find Homebrew commands, butsudomay not know where Homebrew installed them.

On Linux, Homebrew commands may live somewhere like:

On macOS, they are commonly under:

on Apple Silicon, or:

on Intel Macs.

The simple one-command solution

A quick workaround is to resolve the command path before callingsudo:

This works becausewhich nethogsis evaluated by your normal shell, using your normalPATH, beforesudoruns.

So instead of askingsudoto findnethogs, you give it the full path directly.

A shell function for one command

You can wrap that in a function:

This lets you run:

and still preserve arguments correctly.

A generalbrew-sudohelper

A better cross-platform approach is to define a small helper that asks Homebrew for its prefix, checks bothbinandsbin, and then runs the matching executable withsudo.

Now you can run Homebrew-installed commands with root privileges like this:

This works across Linux and macOS becausebrew --prefixreturns the correct Homebrew prefix for the current system.

Defining command-specific wrappers

You can then define convenient wrappers in terms ofbrew-sudo:

This gives you the best of both worlds:

while internally resolving to something like:

on Linux, or the corresponding Homebrew path on macOS.

Full version

Put this in a shell file sourced by bothbashandzsh, or copy it into both~/.bashrcand~/.zshrc:

A note onsudoand Homebrew

This approach does NOT runbrewitself withsudo. It only usesbrew --prefixto locate Homebrew’s installation directory, then runs a specific Homebrew-installed executable withsudo.

That distinction matters: runningbrew installorbrew upgradewithsudois generally the wrong approach, but running a tool likenethogswithsudois appropriate when the tool itself needs root privileges.

Alternative: adding Homebrew to/etc/sudoers

Another possible solution is to teachsudoabout Homebrew’s executable directories.

On many systems,sudouses a restricted path configured in/etc/sudoers, often through a setting calledsecure_path. You can inspect and edit it with:

You may see a line like this:

One could add Homebrew’sbinandsbindirectories there. For example, on Linuxbrew:

Or on Apple Silicon macOS:

After that, this may work directly:

However, this approach has a security tradeoff.

It does not give users newsudopermissions by itself. A user still needs to be allowed to run commands withsudoin the first place. But it does make Homebrew-installed commands part of sudo’s command lookup path.

That can be undesirable because Homebrew prefixes are often writable by the normal user, or by users in an admin group. In general, root’sPATHshould avoid directories that non-root users can modify. Otherwise, it becomes easier to run a user-controlled executable as root accidentally.

For that reason, I prefer the wrapper approach shown above.

Bootstrapping chezmoi from HTTPS to SSH After First Apply

When I bootstrap a new machine withchezmoi, I usually start by cloning my dotfiles repo from GitHub over HTTPS:

That works well for the very first setup, because my SSH keys are not installed yet.

After the firstchezmoi apply, though, my SSH keys are finally in place, and I want the dotfiles repository itself to switch from HTTPS to SSH automatically.

This sounds simple, but there is a small gotcha.

The goal

I wantedchezmoi applyto do this at the end of the first run:

  • detect that the repo remote is using HTTPS
  • convert it to the SSH form
  • updateoriginautomatically

For example:

  • fromhttps://github.com/username/dotfiles.git
  • togit@github.com:username/dotfiles.git

My first attempt

My first version used arun_once_after_...script that calledchezmoi source-pathto find the source repo:

But when I ranchezmoi apply, I got this:

Why this fails

The problem is that the script is being runbychezmoi apply.

So if the script itself runs anotherchezmoicommand, the second process tries to acquire the same persistent state lock that the originalchezmoi applyalready holds.

In other words:

  • chezmoi applystarts
  • it runs your script
  • your script runschezmoi source-path
  • the nestedchezmoiprocess waits on the lock
  • eventually it times out

The fix

The solution is to avoid callingchezmoiinside the script.

Instead, make the script atemplateand use{{ .chezmoi.sourceDir }}to inject the source directory path when chezmoi renders the script.

Here is the working version.

Working script

Create this file:

Contents:

Why this works

There are two important details here.

1. The script is a template

The.tmplsuffix tells chezmoi to render the file before executing it.

That means this line:

gets replaced with the actual source directory path ahead of time.

No extrachezmoiprocess is needed.

2. The script runs after “apply”, and only once

Because the file name starts withrun_once_after_, chezmoi runs it after the apply phase, and only once per machine unless the script changes.

That makes it a good fit for first-boot setup tasks like this one.

A note about the working directory

One subtle point: chezmoi scripts donotrun in the source repo by default.

So even though we know the source directory, we still need to explicitly run:

before callinggit remote get-urlorgit remote set-url.

Resetting the script state

If you need to test the script again after it has already run successfully, you can clear chezmoi’s script state:

That letsrun_once_scripts execute again.

Final thoughts

This ended up being a neat example of a general chezmoi rule:

If a script is already running insidechezmoi apply, avoid launchingchezmoiagain from that script.

When you need chezmoi-specific information in a script, templating is often the better solution.

For my bootstrap flow, this gives me the best of both worlds:

  1. clone over HTTPS when no SSH key exists yet
  2. install SSH keys during the first apply
  3. automatically switch the dotfiles repo to SSH at the end

Exactly what I wanted.


If you use a similar bootstrap flow, hopefully, this saves you from the persistent state lock timeout.

Fedora Silverblue: upgrading

I’m continuing my evaluation of the FedoraSilverblueLinux distribution,which I started some time ago.

Let’s upgrade the system!

As mentioned in theofficial documentation:

On Atomic Desktops, you can keep using your computer while applying OS updates as they are downloaded and installed in the background. Once an update has been installed, you can reboot your computer to start using the new version. You will not have to wait for the update to be installed either during shutdown or boot up.

On Fedora Silverblue and Fedora Kinoite, OS updates are downloaded automatically and you will be notified when updates are ready to be applied via a reboot. This behavior can be changed in the settings.

On a fresh installation, these are the details of the installed system:

If we open the Gnome Software, we can see that updates are already detected:

Actually, the system is already downloading the updates (and applying them on a new image); after a while, you can simply restart:

After the reboot, the updated image will take effect:

In particular, just rebooting will lead you to a possibly already downloaded and updated image.

Automatic update behavior can be seen in the Gnome Software preferences:

From the command line, you can check available updated images:

Note the leading “dot” telling you what image you’re currently on.

After reboot, here’s the updated information:

You can also use the GRUB menu to possibly boot into the previous image:

You can then verify that you booted into the previous image:

The “status” command also shows when the new image is being downloaded; for example, after a fresh installation, a new upgrade will be automatically checked and downloaded:

You can also update using the command line. To check for available updates without downloading them, run:

For example, let’s say that I don’t have the latest update (see the status), I check for possible new updates:

I can perform the upgrade with:

And reboot.

With “–preview”, you can also see what’s going to be upgraded, for example:

Stay tuned for more blog posts about Fedora Silverblue!

Running Waybar with a Custom Configuration Directory in Sway

When setting upSwayas your Wayland compositor, you might want to organize yourWaybarconfiguration in a non-standard location — for example, keeping a dedicated~/.config/waybar/sway/directory to separate your Sway-specific bar configuration from others.

This seemingly simple task comes with a couple of subtle pitfalls worth knowing about.

The~Expansion Problem

The most natural approach would be to launch Waybar directly from thebarblock in your Sway config:

Unfortunately, thisdoes not work. Theswaybar_commanddirective does not perform shell expansions, so~is passed literally to the command instead of being expanded to your home directory. Waybar will fail to find the configuration file.

A workaround is to launch Waybar viaexecinstead:

However, this approach has its own drawback: Waybar launched viaexecis no longer managed by Sway’sbarsubsystem. This means that Sway bar commands — such asswaymsg bar hidden_state toggleto show/hide the bar —will not work.

The Solution: A Wrapper Script

The cleanest solution is to write a small wrapper script that handles the expansion and launches Waybar with the desired configuration:

Make it executable:

Then reference it in your Sway config:

Now Waybar is properly managed by Sway’s bar subsystem, and the script handles path expansion.

The PATH Problem

There is one more subtle issue: the script lives in~/.local/bin/, which maynot be inPATHwhen Sway starts. Sway is typically launched from a display manager or TTY, where the environment is minimal and does not source your shell’s configuration files (e.g.,~/.bashrcor~/.zshrc).

To ensure~/.local/binis inPATHfor Sway and all processes it spawns, add it in your login shell profile:

Your display manager or TTY login will source this file, making the script discoverable when Sway starts.

A first look at Fedora Silverblue 43

I’m going to test the Fedora 43 Linux distribution in its“immutable” “atomic” shape, Silverblue.

Fedora Silverblue is Fedora’satomic, GNOME-based desktopbuilt around animage-based, mostly read-only systemrather than a traditional mutable Linux install.

  • As anatomic desktop: the base OS is image-based, updates are applied as a new deployment, and you switch to it on reboot. That gives you aneasy rollbackif an update goes wrong.
  • It is designed toseparate apps from the host OS: GUI apps are primarily installed as Flatpaks, command-line/dev tooling is commonly run in Toolbx containers, and traditional RPMs can still be added through therpm-ostree layeringwhen needed.
  • The main upside isstability and reproducibility: Fedora says Atomic Desktops are intended to be more stable, easier to test, and well-suited to containerized apps and development.

Thus, it is rather different from other standard “mutable” Linux distros, especially when it comes to installing software.

I’m starting a series of blog posts on Fedora Silverblue.

At the moment, I’m NOT considering using it as my daily driver (which, for now, isArch, specificallyEndeavourOS).

The installation process

The installation procedure is the typical Fedora one:

It detected my language (though I then switched to English):

Then, I switched to the Italian keyboard layout:

I checked the time, and it was already correct; I also checked the Internet time synchronization:

Time to deal with disk partitioning (“Installation Destination”).

Since I’m testing this on a virtual machine, I’ll stick with the automatic partitioning.

And we can now start with the installation:

The “Writing objects” text stays there for a long time.

Then, the rest of the installation steps are performed, including the installation of apps:

Then, the progress bar basically goes directly to the end. The installation completed in a few minutes:

First boot

During the first boot, you configure a few things (most of them, taken from the installation process, but to be confirmed):

I’ll skip the GNOME tour.

The installed system

Concerning installed applications, it’s rather minimal:

You have a terminal (not the Gnome terminal, but “ptyxis) and Firefox:

Let’s see the layout of the partitions:

So the main partitions areBTRFS.

Note the symlinks (especially for home):

Here’s the Gnome software center:

Of course, since Silverblue is immutable (you can’t modify the root system), applications are installable through flatpaks from the software center:

Concerning the installed apps:

They are also flatpaks.

However, concerning the “System Apps”:

I seem to understand they are “layered” on the base image:

There are already some updates:

We’ll deal with upgrades in a future blog post.

That’s all for the moment, but I’ll keep exploring and experimenting with this distro.

Neovim and LaTeX with LazyVim, part 3: custom commands

This is a follow-up to thefirst post on Neovim and LaTeX andthe second one.

If you write LaTeX in Neovim using theLazyVimdistribution, you already get a fantastic editing experience thanks to VimTeX and texlab. But there’s one thing that often trips people up:how do you quickly wrap selected text in\emph{…},\textbf{…}, or other LaTeX commands?

The answer ismini.surround— and with a small buffer-local configuration, it becomes a LaTeX wrapping powerhouse.


What mini.surround Gives You (Out of the Box)

LazyVim ships with themini.surroundextra, which you can enable in yourlazy.lua(or wherever you manage extras):

Once enabled, you get operations like:

KeymapAction
gsaAdd surrounding
gsdDelete surrounding
gsrReplace surrounding
gsfFind surrounding

For example, visual-select a word and pressgsa"to wrap it in double quotes, orgsa)for parentheses. Great — but what about LaTeX-specific commands?


The Problem with LaTeX Commands

VimTeX gives you text objects, motions, completion, and much more — but it doesn’t ship a built-in “surround this selection with\emph{…}” feature. That’s wheremini.surround‘scustom surroundingscome in.

We can teachmini.surroundto understand LaTeX commands by defining custom surroundings in a filetype-specific Lua file.


Setting Up Custom LaTeX Surroundings

Create (or edit) the file~/.config/nvim/after/ftplugin/tex.lua. This file is automatically sourced by Neovim whenever you open a.texfile.

Why ftplugin?Files in this directory are loadedafterall plugin configuration, and only for the matching filetype. This means our settings are buffer-local and don’t interfere with any other filetype.


How It Works

Thecmd_surroundhelper function does two things:

  1. input: A Lua pattern that matches\cmd{...}so thatgsdandgsrknow what tofind and remove.
  2. output: The left (\cmd{) and right (}) strings used whenaddinga surrounding.

We then assign short, memorable single-character IDs to each command.


Using the Surroundings

Here’s what you can do in any.texbuffer:

Adding a Surrounding

Visual-select some text, then:

KeymapResult
gsae\emph{selected text}
gsab\textbf{selected text}
gsai\textit{selected text}
gsat\texttt{selected text}
gsau\underline{selected text}
gsas\textsc{selected text}
gsaq(add opening and closing LaTeX quotations, i.e., two backticks and ”)

You can also usegsain normal mode with a motion:gsaeiwwraps the current word in\emph{…}.

Deleting a Surrounding

Place your cursor inside a command and press:

KeymapAction
gsdeRemove\emph{…}, leaving the inner text
gsdbRemove\textbf{…}
gsdiRemove\textit{…}

Replacing a Surrounding

Want to change\emph{…}to\textbf{…}? No problem:

That’sgsr(replace surrounding), thene(find\emph{…}), thenb(replace with\textbf{…}).


A Practical Example

Suppose you have this text:

You visual-select “very important” and pressgsab. You get:

Now you decide that emphasis is better. With the cursor inside the\textbf{…}, pressgsrbe:

And if you want to remove the markup entirely:gsde:


Extending with Your Own Commands

The pattern is easy to extend. Just add more entries tocfg.custom_surroundings:

Pick single characters that are easy to remember and don’t conflict with built-in mini.surround ids (avoid(,),[,],{,},',",`).


A Note on Limitations

Theinputpatterns use Lua’s pattern matching, whichcannot handle nested braces. For example,\emph{foo {bar} baz}may not be matched correctly bygsdorgsr. For the vast majority of LaTeX writing, this is not an issue — but it’s worth keeping in mind if you work heavily with nested commands.


Happy LaTeX writing! 🎓

Run mako in Sway/Hyprland, but not in KDE (Wayland)

If you use aWaylandcompositor likeSwayorHyprland,makois a great lightweight notification daemon. Many distros make it “start automatically” via asystemd user service, so you don’t need to addexec makoto your compositor config.

I’m experimenting with a setup with KDE, Sway, and Hyprland installed on the same machine and used by the same user, and there’s a catch:KDEon Wayland is also a Wayland session, so the same auto-start logic can kick in there too — and you end up with mako running in Plasma when you don’t want it.

This post shows a clean fix:keep mako auto-starting in Sway/Hyprland, but skip it in KDE, using asystemd drop-in overridethat lives nicely in your dotfiles (e.g., with chezmoi).


Why mako starts in KDE

On many systems, the provided user unit checks only whether you’re ina Wayland session:

KDE Wayland setsWAYLAND_DISPLAYtoo, so mako passes the check and runs.


The fix: restrict the systemd unit to Sway/Hyprland

Create a systemd user drop-in:

This opens an editor and writes a file under:

  • ~/.config/systemd/user/mako.service.d/override.conf

Put this in that file:

Apply it:

Now mako should start in Sway/Hyprland, and be skipped in KDE.


Verify what systemd is using

To see the merged unit (vendor file + your override):

To confirm whether it’s running and why:

If you log into KDE and it’s skipped, you’ll typically see a reason related to theExecCondition.


Making it portable with chezmoi

Sincesystemctl --user editproduces a file in your home directory, it’s perfect for dotfiles.

Withchezmoi, just track:

  • ~/.config/systemd/user/mako.service.d/override.conf

On another machine, once mako is installed, that drop-in will be picked up automatically. The only thing to remember is thatsystemd reads unit changes after a reload(or next login), so if you want it to take effect immediately afterchezmoi apply, run:

(try-restartis nice because it won’t error if mako isn’t running.)


Bonus note: D-Bus activation

Depending on your distro and setup, mako can also be started via D-Bus when a request for notifications is made. If you find mako still appears in KDE even when the unit is skipped, check whether it’s being D-Bus activated — and then either:
– rely on a KDE-native notification daemon in Plasma, or
– mask the D-Bus service fororg.freedesktop.Notificationsfor KDE sessions only.

(Usually, the systemd drop-in above is enough.)

Using KWallet in Sway for Chrome

If you useKDEandSway(orHyprland) on the same machine with the same user (something I’m experimenting with), when you launch Chrome and log in with your user in KDE, and then switch to Sway, you’ll see that your account is marked as “Paused”: you have to log in again. The same holds the other way round.

That’s because in KDE, Chrome stores the credentials in KWallet, while Sway does not.

To fix this annoying problem, you have to ensure to run Chrome in Sway with the option “–password-store=kwallet6”.

To do that, you can either manually launch Chrome with that option or create the file “~/.local/share/applications/google-chrome.desktop” starting from the default file (in Arch it’s “/usr/share/applications/google-chrome.desktop”) and ensure the occurrences of the “Exec” line have that option, i.e.,

The desktop file in your home folder will have precedence over the default one.

However, while KDE automatically unlocks the KWallet when you log in, Sway does not. The first time you launch Chrome from a Sway session, you’re asked to open the wallet with your login password:

To let KWallet use your login credentials automatically (as KDE does, thanks to “/etc/xdg/autostart/pam_kwallet_init.desktop”), you need to tell Sway to start the corresponding PAM module.

The ArchWiki recommendation for “a window manager” setupis simply: runpam_kwallet_initfrom your WM/compositor startup.

Add this to~/.config/sway/config(early in startup, before apps that need secrets):

That’s usually enough to avoid the post-login password prompt,provided PAM is already set up correctly(see the next section).

Important:pam_kwallet_initonly works if PAM captured your password

pam_kwallet_initdoesnotmagically know your login password. It relies on the PAM module (pam_kwallet5.so) having captured it during login and made it available for the session handoff.

So:

  • If you start Sway via a display manager/session that already haspam_kwallet5.soin its PAM stack, then running/usr/lib/pam_kwallet_initIn Sway, the wallet should unlock automatically.

  • If you start Sway via a path thatdoesn’t run the kwallet PAM module (common when starting from TTY, or via some greeters, depending on config), thenpam_kwallet_initwon’t have credentials to use, and you’ll still be prompted.

Installing Linux on a Dell Pro Max Tower T2

I’ll show how I installed Linux (EndeavourOS, i.e., Arch) on a Dell Pro Max Tower T2.

This is quite a powerful computer! Here are a few screenshots taken from Windows 11:

Before installing Linux on this computer, I had to change the SSD SATA mode from RAID to AHCI, as documented in aprevious blog post. Otherwise, Linux will not detect any SSD.

Prepare the disk with “Disk Management”.

Current situation:

I will not wipe the whole disk because I want to use Windows as well. I won’t touch the other recovery and health partitions either.

Right-click on “C:” and choose “Shrink Volume…”. About 200Gb should be enough for Windows on this computer. Unfortunately, the UI of this dialog is not the best one: you have to compute how much space to remove from the current partition and check whether the “Total size after shrink” is what you want.

I’m also deleting the “D:” volume (I’ll use it for additional partitions both on Linux and maybe on Windows).

Here’s the final result:

Let’s reboot the computer and turn off secure boot. Press F2 when the computer is turning on to enter the BIOS.

Very nice looking:

NOTE: You can use the mouse to navigate the BIOS. In my case, the computer is connected to a KVM switch for keyboard and mouse. When in the BIOS, the mouse just moves vertically. I had to plug the mouse directly into the USB port of the computer to use it inside the BIOS.

Select “Boot Configuration” where you see the “Boot Sequence” (that’s useful in the future to change the boot order or delete old entries). Scroll down til you get to secure boot and disable it:

Let’s apply changes and exit.

I downloaded the EndeavourOS ISO Mercury Neo 2025.03.19, put it into a Ventoy USB stick.

It looks like this PC can boot from USB only from the first port from the bottom (at least in the front: I haven’t tried the ports on the back):

When the computer starts, press F12 for the temporary boot menu. Select the USB stick. Then you get the Ventoy menu where you select the EndeavourOS distribution. I’ll use grub2 mode.

The installation is the typical one forEndeavourOS, which I havealready blogged about.

After several weeks, I can confirm that Linux works like a charm on this powerful computer! 🙂