What is the reason? Fedora just works. The installation was done in a few minutes. (Almost) all packages are there and GNOME runs wonderfully out of the box. DNF5 as package manager comes close to apt.

My AMD desktop doesn't cause any trouble and my Framework 12 runs fine.

Almost boring :)

Unfortunately, there is no native app for Linux, but fortunately wine can now very well start Windows apps under Linux.

After the regular installation, the app did not work. The screen was not updated, only when the window was resized.

The reason appears to be that the app is based on QT and requires 3D acceleration. The solution was to make wine 3D capable. Simply install dxvk via winetricks, i.e. a Vulkan-based translation layer for Direct3D.

winetricks dxvk

After that, the app runs perfectly.

It would be great if there was simply a native Linux app.

(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.