But exactly 1000 days ago, I switched back from Mac to Linux. Without a doubt, the best decision I could have made as a tech enthusiast.

I was already a Linux user in the late 90s and early 2000s (SuSE 5.1, Redhat 6, Mandrake, and Slackware), but then the Mac became too tempting with the iBook 12 G4. What a dream device! Additionally, macOS appealed as an “easy-to-use” Unix system.

Even though I had already been experimenting in the last years with Linux again on an “old” Thinkpad T460 and the MNT Pocket Reform, my main computer was still a MacBook.

Then, exactly 1000 days ago, a Tuxedo Pulse 14 finally replaced the MacBook as my main device.

Although it was a good choice, the hardware has since been replaced multiple times. But Linux has always remained.

Current hardware includes a self-built AMD desktop with an orange case and a Framework 12 as my laptop. The home server is a HPE ProLiant MicroServer Gen10.

Of course, I’ve been actively hopping distros during this time.

On the desktop: Fedora → Debian Stable → openSUSE Tumbleweed → Debian Stable → openSUSE Tumbleweed On the server: Debian Stable → openSUSE Slowroll → Debian Stable

openSUSE Tumbleweed seems to be the winner ... for now.

The same hopping around happened on the desktop environment: GNOME → SWAY → NIRI → GNOME → NIRI / GNOME

From a purely emotional perspective, I think GNOME will win out in the long run.

At first, I took the GNOME beginner’s route and installed a ton of extensions because things were missing. By now, I feel like I understand the GNOME way (and it’s fantastic!), and I only run two extensions: Caffeine and Audio Switch Shortcuts. No unnecessary stuff or UI clutter.

But NIRI is also used frequently. To me, NIRI and GNOME feel like closely related cousins ;) A GNOME with integrated NIRI will remain an unfulfilled dream.

SWAY also continues to tempt me daily with its sleek system access.

KDE is also frequently installed and uninstalled. I understand the approach, but I just can't warm up to the design.

That’s the beauty of Linux: the freedom to choose from a variety of desktops that can be installed in parallel. The apps don’t care what they run on or in.

The same freedom applies to hardware. Apple builds fantastic laptops! But I was limited to one manufacturer. If they did something (even ethically) that I didn’t like, I was stuck. With Linux, I don’t have this problem: I can simply buy from someone else next time.

This is currently the case with my Framework 12. I like the device, but I don’t like all the projects the company currently backs. So, for my next purchase, I can decide whether it will be another Framework or a device from a different manufacturer.

Switching to Linux also had the wonderful side effect of changing the ecosystem around me. iOS was replaced by free Android alternatives: via e/OS and iodeOS, I landed on GrapheneOS. Currently, I'm even playing around with SailfishOS.

Services have also changed: my music streams via Navidrome, and my family organizes photos using ente. KeepassXC and KeepassDX replaced 1Password.

Even home automation switched from HomeKit to Home Assistant.

So, 1000 happy days with the decision to switch—and never going back to proprietary! It wasn’t always a painless transition. But it was worth it.

(The image was altered to make the glitch more visible)

This drives my mad, so I choose a simple solution: fix it with a custom theme!

I use the ADW-GTK3 theme for GTK3 apps, so simple theme which includes ADW-GTK3 (installed in ~/.local/themes/adw-gtk3/) works great.

I call the theme rounded (because of the corners) and it is installed in ~/.local/themes/rounded/gtk-3.0/. There create a gtk.css.

@import url("../../adw-gtk3/gtk-3.0/gtk.css");

window decoration {
  border-radius: 15px;
  box-shadow:
    0 3px 8px 0 rgba(0, 0, 0, 0.3), 
    0 0 0 0 @headerbar_bg_color;  
}

For a first test start firefox via terminal:

env GTK_THEME=rounded firefox

or

env GTK_THEME=rounded librewolf

To make the fix permanent, simply modify the .desktop file.

Firefox:

cp /usr/share/applications/firefox.desktop ~/.local/share/applications/

Then, in the firefox.desktop file, change the Exec line to the following:

Exec=env GTK_THEME=rounded firefox %u

Librewolf:

cp /usr/share/applications/librewolf.desktop ~/.local/share/applications/

Then, in the librewolf.desktop file, change the Exec line to the following:

Exec=env GTK_THEME=rounded librewolf %u

So, it’s basically hypocritical that I have AI write small scripts for me... but it’s just so easy.

The starting point

I use two computers in my daily life: a desktop and a laptop. I sync many dotfiles between them using chezmoi, but since GNOME stores its settings in dconf, I need a tool for that. Preferably with a UI that integrates into GNOME.

syncGNOME

syncGNOME is a simple little Python app that allows importing or exporting entries from dconf via git. The corresponding entries can be added to a config file, as well as paths that should be excluded—like my wallpaper settings, for example. Additionally, the device name in gsconnect can be set to the hostname. Maybe that’s very specific to my use case.

Update

Because of the AI policy of Codeberg I removed the file.

The most well-known example by now is Niri, of which I'm a big fan.

Niri is fast, simple, and powerful to configure, but it needs an ecosystem around it: panel, dock, wallpaper, screen locker, and so on.

With programs like waybar, quickshell, swaybg, or swaylock, there’s a lot that makes Niri perfect. In short: I love Niri.

But what I love even more is the ecosystem and, above all, the general approach to usability in GNOME. I find the use of the dock particularly brilliant. GNOME seems to have been created exactly for my way of thinking.

Now, GNOME doesn’t offer scrollable tiling, but there is an extension that, among other things, also served as inspiration for Niri: PaperWM

In PaperWM you can configure a huge, huge, huge amount. The settings might overwhelm you a bit at first, but gradually, you can build a wonderful scrollable tiling experience for GNOME.

You can also adjust settings individually for specific programs using the window class or window title. For example, Tuba and Fractal both have 50% width and share workspace 2 for me.

Because of the dream combination of GNOME and scrollable tiling, PaperWM is currently my first choice...

I'm pretty sure everything is fixed in Testing or Sid, but then I might as well just go back to openSUSE as a rolling release.

I finally did that and I'm really excited about it. What's interesting is that I'm not going back to tiling managers like Niri (like I used to). I'm sticking with GNOME. Version 50 especially feels really smooth.

I'm a bit sad, because at heart, Debian was perfect in every way. Just not perfect for my specific hardware...

Personally, I think libadwaita's design language is the best thing that could happen to a UI. Kind of like Apple back in the day. I just love the look of GTK4 and Adwaita.

adw-gtk3

Since many great apps still use GTK3, adw-gtk3 is a good theme to make those apps look more similar to GTK4. It doesn’t quite work because GTK3 only has rounded corners at the top of the window, while GTK4 has all corners rounded. You could tweak it to match, but it wouldn’t make sense since GTK3 apps often have a status bar at the bottom of the window.

I just installed the gtk-3.0 files, because I have no need for tweaking GTK4.

tweaking Firefox (or Librewolf)

Firefox (or in my case, Librewolf) also still uses GTK3 but can have rounded corners at the bottom as well. You just need to enable it via about:config. Just set widget.gtk.rounded-bottom-corners.enabled to true.

fixing glitches

Since adw-gtk3 isn’t designed with this in mind (round corners in the bottom), we still need to do a bit of manual tweaking to avoid display issues.

I also have a scaling glitch. On my laptop with 125% UI scaling, Firefox looks good, but on my desktop with 150%, I unfortunately often get a display glitch when moving the window. A dark line appears at the top of the window. This, as mentioned, is under GNOME 48 and only happens with Firefox/Librewolf on my setup (but maybe on yours too).

The solution is both complicated and simple at the same time:

Firefox gets its own GTK theme, which modifies adw-gtk3.

The theme add border-radius and disables the 1px border that causes the glitch.

The “theme” uses a gtk.css file, and for me, it's located in ~/.local/share/themes/gtk-3.0/.

It assumes that adw-gtk3 is also in ~/.local/share/themes. Otherwise, the path needs to be adjusted.

@import url("../../adw-gtk3/gtk-3.0/gtk.css");
decoration {
  border-radius: 15px;
  box-shadow:
    0 3px 8px 0 rgba(0, 0, 0, 0.3),
    0 0 0 0 @headerbar_bg_color;
}

Now we just need to start Firefox individually with this theme. That works with

env GTK_THEME=rounded firefox

For a permanent fix, we copy the relevant .desktop file from /usr/share/applications/ to ~/.local/share/applications/ an adjust the Exec entries to

Exec=env GTK_THEME=rounded /usr/lib/firefox-esr/firefox-esr %u

For Librewolf, of course, the corresponding launcher needs to be adjusted.

still stable with a bit of frankendebian

Debian stable, combined with backports and Flatpak, is still enough for me.

I’ve only broken the golden rule that stable and testing must never be mixed (FrankenDebian) for one package: framework-tool

This tool is handy for managing my frame.work 12 from the terminal... the charging limit and stuff like that.

But apt configuration does allow you to set the priority of the sources, so only this one package is installed from the testing repository.

more and more love for GNOME

Even after four months, it’s clear to me that there’s no better desktop environment than GNOME.

Sometimes I feel like the system was built just for me. Sure, there are one or two things I’ve tweaked, but basically, the system is perfect.

The only thing is, it would be nice if GTK3 and GTK4 were a bit more consistent… but it’s fine as it is.

understanding systemd (a bit)

I understand systemd more and more. Whether it's creating services or reading logs. I don't know where the hate comes from. I find it quite practical.

A quick disclaimer: I'm not entirely sure what I'm doing here. This weekend was my first time working with podman. So... try this at your own risk!

a little background first

On the mac, Devonthink has always been—and still is—the best program ever. Simply because all documents are managed locally on the computer. In other words, the app doesn’t require the cloud. When I switched to Linux, it really bothered me that I couldn't find a suitable alternative. Paperwork, for example, also manages documents locally on the computer, but its design was too basic (in my opinion), and I just couldn't get into it.

paperless-ngx

Paperless-ngx is a community-supported open-source document management system that transforms your physical documents into a searchable online archive so you can keep, well, less paper.

This quote from the homepage describes paperless-ngx pretty well, though the “online” part bothered me a bit. I don't want to store my files online on a server, and keeping them on a local NAS doesn't make sense either, because then I wouldn't have them with me when I'm on the go.

solution: local paperless-ngx

Podman comes to the rescue. Thanks to Podman, I can run Paperless locally on my computers using containers. It was surprisingly easy (I only wasted an entire Saturday experimenting with it).

installation

preparation

Well, you need podman ...

Debian: sudo apt install podman-compose

openSUSE tumbleweed: sudo zypper in python314-podman-compose

container setup

First, you need to create a container using Podman. To do this, you’ll need three files in a folder (in my case, paperless-ngx). This folder is simply located in the user’s home directory.

I mainly followed these instructions on linuxguides.de (thanks for the tip Christian!) and the output of the paperless-ngx installer.

.env (hidden file):

COMPOSE_PROJECT_NAME=paperless

docker-compose.env:

PAPERLESS_TIME_ZONE=Europe/Berlin
PAPERLESS_OCR_LANGUAGE=deu+eng
USERMAP_UID=0
USERMAP_GID=0

docker-compose.yml:

name: paperless
services:
  broker:
    image: docker.io/library/redis:8
    restart: unless-stopped
    volumes:
      - redisdata:/data
  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - broker
    ports:
      - "8000:8000"
    volumes:
      - ~/Dokumente/Paperless/Data:/usr/src/paperless/data:Z
      - ~/Dokumente/Paperless/Media:/usr/src/paperless/media:Z
      - ~/Dokumente/Paperless/Export:/usr/src/paperless/export:Z
      - ~/Dokumente/Paperless/Import:/usr/src/paperless/consume:Z
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
volumes:
  redisdata:

I decided to use SQLite as the database because it will allow me to easily sync it between my computers later using Synthing.

It is important to adjust the volumes. These are located in my “Documents” folder under “paperless.”

Data: the database

Media: all the files

Export: Export Folder

Import: Drop documents in this folder for adding them

The “paperless” folder contains the entire contents of paperless-ngx, making it very easy to back up or sync.

container compose

In that folder, just run

Debian: podman compose up

openSUSE tumbleweed: podman-compose up

and everything will be installed.

start and stop the container

The paperless-ngx container doesn't need to run all the time—only when I need to access it. So I wrote a little Bash script to start or stop the container. Just a quick heads-up: I'm a novice and like to keep things colorful ;)

paperless.sh:

#!/bin/bash

set -euo pipefail

# Colors
readonly BLUE='\033[0;34m'
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly NC='\033[0m'

BROKER="paperless_broker_1"
WEBSERVER="paperless_webserver_1"

# Check, if container are running
both_running() {
    [ "$(/usr/bin/podman inspect -f '{{.State.Running}}' "$BROKER" 2>/dev/null)" = "true" ] &&
    [ "$(/usr/bin/podman inspect -f '{{.State.Running}}' "$WEBSERVER" 2>/dev/null)" = "true" ]
}

# Start Containers
start_containers() {
    echo -e "${YELLOW}🟡 Starting $BROKER${NC}"
    /usr/bin/podman start "$BROKER" >/dev/null 2>&1
    sleep 2
    echo -e "${YELLOW}🟡 Starting $WEBSERVER${NC}"
    /usr/bin/podman start "$WEBSERVER" >/dev/null 2>&1
    echo -e "${GREEN}🟢 Both Containers running.${NC}"
}

# Stop Containers
stop_containers() {
    echo -ne "${YELLOW}⚠️  Stop Container? ${NC}"
    read -p "(j/n) [n]: " answer
    echo
    if [ "$answer" = "j" ]; then
        echo -e "${YELLOW}🟡 Stopping $WEBSERVER${NC}"
        /usr/bin/podman stop "$WEBSERVER" >/dev/null 2>&1
        sleep 2
        echo -e "${YELLOW}🟡 Stopping $BROKER${NC}"
        /usr/bin/podman stop "$BROKER" >/dev/null 2>&1
        echo
        echo -e "${GREEN}🟢 Both Containers are stopped.${NC}"
    else
        echo -e "${RED}🔴 Cancel: Containers still running.${NC}"
    fi
}

# Main
echo
echo "### Paperless-ngx - Podman ###"
echo
if both_running; then
    stop_containers
else
    start_containers
fi

Access Paperless

Just go to http://localhost:8000 in your browser, and everything works perfectly.

Sync and backup

As mentioned earlier, the “Paperless” folder in “Documents” contains everything and can be synced between computers using Syncthing, for example. This folder is also very easy to back up.

Manage podman

Of course, you can also do this via the CLI, but I like the simplicity of cockpit, which can also be used on Debian. Cockpit has a handy module for managing Podman.

Hardware

At 14, owning a stereo system was the biggest thing – even at almost 50, it still is. I run two 1980s Magnat speakers through a Rotel A12MKII amplifier.

The amplifier supports Bluetooth, but somehow it’s just easier to run 15 meters of audio cable across the room.

Software

You’ve tried music players on Linux, and so much of it is either very ugly or too bloated.

But there’s one highly praised option: Amberol.

Amberol is simple and looks good. You just open a folder with files, and they play—no database or other unnecessary bells and whistles.

Now there’s still the issue that changing the audio output in GNOME is cumbersome and has to be done through Settings. But the Audio Switch Shortcuts extension solves this problem—with keyboard shortcuts, you can easily switch between devices.

I had a brief window—okay, a few days—to distro-hop again after GNOME 50 was released, but then I realized ... I can just wait another 1.5 years for Forky. So it is still GNOME 48 for me :)

Testing laptop

Because I have a fantastic ThinkPad T460 sitting on my desk as a third machine, I’ve chosen it as the test machine for the upcoming Debian 14 (testing). This gives me a good preview of what’s coming, and honestly, I don’t quite dare to run Testing or Unstable in production. It’s supposed to work well, but Stable just runs too smoothly to switch.

Freeze solved

After my desktop (AMP Ryzen 5 CPU with Radeon RX 6500 XT GPU) kept freezing unpredictably for a while, the problem appears to have been resolved thanks to a newer kernel, AMD firmware and MESA from the backports repo.

More backports stuff

Recently, I also experimented with building backports for personal use, thanks to these instructions: SimpleBackportCreation. Works surprisingly simple. However, since the GNOME app ecosystem is focusing on Flatpak, installing software via Flatpak is more convenient.

Homelab

Now that my fiber optic connection is finally arriving soon, my server (also running Trixie) will take on entirely new tasks. I’m hoping my 'homelab' will grow a bit, and I’ll dive into something I currently know nothing about: containers. I’d therefore appreciate any tips, guides, or recommendations! Docker, Podman ... what to choose? Tips are more than welcome!