in ♥️ with linux

I use two computers: a desktop and a laptop.

Both computers should always be synchronized. Syncthing takes care of my files (music, images, documents), but the configurations should also always be the same.

Many Linux programs store their settings in the hidden .config directory. However, I don't want this folder to be completely synchronized, just individual files ... so called dotfiles.

This is where dotdrop comes in.

Dotdrop is a dotfiles manager that provides efficient ways to manage your dotfiles. It is especially powerful when it comes to managing those across different hosts. The idea of dotdrop is to have the abilit``y to store each dotfile only once and deploy them with different content on different hosts/setups.

Put simply, dotdrop makes a copy of the file in a specified directory and also takes care the permissions. This directory can then be synchronized between two computers using git (or any other tool).

It uses the hostname as the profile. This means that the configuration can also be used to specify which computer the file should be installed on.

Add a file to dropdrop

dotdrop import FILENAME

This adds to the profile of the current computer. However, a different profile (usually the host name of the other computer) can also be specified during import.

dotdrop import --profile=HOSTNAME FILENAME

The config file can be put in ~/.config/dotdrop/, among other places. However, since I also push other things to git (Codeberg) via this directory, I decided to use ~/.dotdrop.

I also use two configuration files: one for user files and one for system files.

dotdrop import --cfg=~/.dotdrop/config-user.yaml FILENAME

or

dotdrop import --cfg=~/.dotdrop/config-root.yaml FILENAME

Remove a file to dropdrop:

Also very simple. Just go to the correct folder and

dotdrop remove FILENAME

Installing a file

Once the file has been assigned to the corresponding profile in the configuration file, it is installed on the computer using the following command. Before doing so, it is of course advisable to execute a git pull to ensure that the current file has been loaded into the dotdrop folder.

dotdrop --cfg=~/.dotdrop/config-user.yaml install

Or for systemfiles:

sudo dotdrop --cfg=~/.dotdrop/config-root.yaml install

Customisation

The great thing about dotdrop is that it is very easy to integrate into your own scripts. For example, I did not find that the file is always automatically added to all profiles during import. Perhaps this is possible by default, but I did not find anything about it in the documentation.

So I simply execute the command twice with this script:

#!/bin/bash
CONF="~/.dotdrop/config-user.yaml"
PROFILES=(
"hostname1"
"hostname2"
)
for prof in "${PROFILES[@]}"; do
dotdrop import --cfg=$CONF --profile=$prof $1
done
dotdrop --cfg=$CONF profiles

Conclusion

There are similar tools to dotdrop. The best example is chezmoi, which I really enjoyed using on openSUSE. However, this is not included with Debian. It was a bit of a shame at first, but now I like the simplicity of dotdrop.

I have wanted to learn programming for a while now. My last period of active coding was actually back in school, using Turbo Pascal and dBase. In between, I dabbled a little with JavaScript, PHP and VBA, but only in a very rudimentary way.

I think Python would be a good fit, so I still need a project. Since I’m now using GNOME, it will be a handful of small scripts that are useful in everyday life.

I don’t enjoy reading long documentation; I prefer to experiment – learning by doing has always worked well for me.

I’m not a big fan of AI; a lot of it is just nonsense. But I’m very impressed by how well the creation of small scripts works in a dialogue. The AI quickly reaches its limits, yet it’s fine for getting started. Especially, it can also explain what it’s doing (or rather it checks what it has done).

So I’m now trying to learn Python with the help of AI through dialogue. My first project is a tool that can sync dconf settings via Git.

You can find the code here: https://codeberg.org/Nasendackel/SyncDconf

Just improve it so I can learn :)

Last weekend, I had a very brief distro-hopping moment.

For 10 minutes, openSUSE was back on my computer. I was surprised myself that I immediately reinstalled Debian 13.

I had assumed that not having a ‘brand new’ system would bother me too much.

But on the contrary: Debian's simplicity and stability brought me back very quickly. It also turns out that I have quite a lot of up-to-date software after all.

Basically, I only use 10 to 15 apps regularly. For some, it doesn't matter that they lag behind in a few features; for others, there's always Flathub.

I use Librewolf as my browser anyway, and it has its own repo.

I get a more up-to-date kernel or firmware via backports.

So I can highly recommend Debian... Simple, refreshingly old-fashioned and stable.

I have purchased four laptops in the last two years (and since switching to Linux).

• Lenovo Thinkpad T460 (refurbished)
• Tuxedo Pulse 14 Gen3
• Lenovo Yoga 7
• Framework 12

No purchase was wasted, as several people (mother-in-law and children) were taken care of.

But it shows that it's not that easy (at least for me) to find a good laptop for Linux. Tuxedo came very close, but 14 inches is just too big for me.

I still think that one of the best laptops (purely in terms of form factor) was the 12-inch iBook G4 or the 11-inch Macbook Air.

When Framework announced a 12-inch device, I didn't hesitate to place my order.

Now it has arrived, and after using it for about two weeks, I can write something about it.

Spoiler: I like it a lot during the day and a little less at night.

But more on that in detail...

This is my configuration:

• CPU: Intel Core – i5-1334U
• RAM: DDR5-5600 – 48GB
• STORAGE: WD_BLACK SN770M NVMe – M.2 2230 – 1TB
• DISPLAY: 1920 x 1200 / Intel® UHD Graphics / Touch and Stylus

More stickers will be added in the future ;)

What's particularly practical about the Framework devices is that I can assign the ports freely. So I have 2x USB-C, 1x USB-A, and 1x HDMI. MicroSD and Ethernet are in the bag. They can be easily replaced.

It would have been perfect if not only the USB-C modules in the housing had been green, but that's just nitpicking.

But what I really like is the workmanship. It's all plastic, but it feels very sturdy. It's very reminiscent of the feeling I had when I first used the iBook G4 12.

The repairability is also terrific. Just remove the keyboard and you can access all components.

The performance is good. I use TuneD on Debian 13. In balanced mode, the fan rarely runs, but I have the subjective feeling that Gnome is sometimes a little sluggish. But it's hardly noticeable. In performance mode, everything runs smoothly and snappy. The fan also makes very little noise here.

It's nice that the ventilation slots are on the back and not on the bottom. This means that using it on your lap is no problem.

The BIOS is also excellent. I can set the battery's charging limit and customize quite a few other settings as well. Just the brightness of the power button alone... handy when suspending.

So, is it the perfect device? Almost. I like it very much and would buy it again. The only problem is the darkness.

Yes, no backlighting for the keyboard. That's quite a disadvantage, and I can only hope that this will be added later.

But otherwise, I'm happy and have the almost perfect Linux laptop.

I switched from openSUSE to Debian stable a week ago. As great as Debian is, it unfortunately has the disadvantage that I could no longer use Niri. That left SwayWM or GNOME.

After a few days, I realised that I don't really need a tiling window manager, I just like working with workspaces.

So the choice fell on GNOME, which I have grown to like very much and, above all, which looks really good. I never warmed to KDE, but everyone has their own preferences.

Since I only learned programming with Turbo Pascal and DBase, the AI had to help out a bit.

I would be delighted if some experts would take a look at the scripts. In my opinion, what the AI has written looks good, but perhaps it could be even better with a real brain.

Files:

You can find all scripts of the following instructions on Codeberg in my dotfiles.

Problem 1: Start apps on a certain workspace

GNOME has workspaces, but I missed being able to start a programme on a workspace with a keyboard shortcut. For example, Tuba (Mastodon) is always on workspace two.

Unfortunately, GNOME does not offer this by default.

Solution 1: Extensions, bash and keybindings

Update: 21.09.2025

I changed everything to a combination of the Auto Move Extension and changing the shortcuts of the dash app via dconf.

For an example:

In the extension I assigned Tuba to Workspace 2 and changed the shortcut of application 4 in the dash to SUPER+SHIFT+T.

Now every time I press SUPER+SHIFT+T either Tuba starts or the app is focused on workspace 2.

Problem 2: Sync Settings

I use two computers: a desktop on my desk and a Framework 12 laptop. GNOME stores its settings in dconf. So I needed a tool that would export certain settings (e.g., keyboard shortcuts), push them to git, and import them back onto the other computer.

Solution 2: Export dconf and sync over git

The AI also helped after I spent a long time explaining what I needed.

#!/bin/bash
set -euo pipefail

# ---------- CONFIG ----------
GITHUB="$HOME/.dotdrop"			
REMOTE="$GITHUB/dotfiles/Gnome"	
mkdir -p "$REMOTE"

DCONFPATHS=(
  "/org/gnome/desktop/wm/keybindings/"
  "/org/gnome/mutter/keybindings/"
  "/org/gnome/settings-daemon/plugins/media-keys/"
  "/org/gnome/shell/"
)
# ----------------------------

# Build readable path list
PATH_LIST=""
for p in "${DCONFPATHS[@]}"; do PATH_LIST+="$p"$'\n'; done

# ---------- ACTION HANDLERS ----------
action_export() {
  cd "$GITHUB"
  git pull --ff-only || { echo "Git pull failed – aborting." >&2; exit 1; }

  for path in "${DCONFPATHS[@]}"; do
    filename=$(echo "$path" | tr '/' '_').conf
    dconf dump "$path" > "$REMOTE/$filename"
  done
  echo "Exported to $REMOTE"

  # exportierte Dateien committen
  git add "$REMOTE/*"
  git commit -m "Export GNOME shortcuts $(date +%F-%T)"
  git push
}

action_import() {
  cd "$GITHUB"
  git pull --ff-only || { echo "Git pull failed – aborting." >&2; exit 1; }

  for path in "${DCONFPATHS[@]}"; do
    filename=$(echo "$path" | tr '/' '_').conf
    file="$REMOTE/$filename"
    [[ -f "$file" ]] && dconf load "$path" < "$file" || echo "File not found: $file" >&2
  done
  echo "Imported from $REMOTE"
}

action_open() {
  echo "Storage location: $REMOTE"
  xdg-open "$REMOTE" || true
}

# ---------- CLI ENTRY ----------
case "${1:-}" in
  export)  action_export ;;
  import)  action_import ;;
  open)    action_open ;;
  *)       echo "Usage: $0 {export|import|open}" >&2; exit 1 ;;
esac

In my case, I export to the .dotdrop directory and sync this with Codeberg via git. Since I also use the dotdrop tool, this directory was the obvious choice.

Problem 3: Power-Screen

I was used to using wlogout in niri or swaywm. Of course, in GNOME wlogout works too, but it didn't really function properly. For example, there is no transparent background.

Solution 3: Simple Python Script

After a long dialogue, the AI created a simple Python script that uses images from the Papyrus icon set.

Set as a shortcut to SUPER+SHIFT+E... Works.

#!/usr/bin/env python3
# coded with the help of AI

import gi, subprocess, os
gi.require_version('Gtk', '4.0')
from gi.repository import Gtk, Gdk, GdkPixbuf

ICON_DIR = "/usr/share/icons/Papirus-Dark/24x24@2x/actions"

class PowerPanel(Gtk.Application):
    def __init__(self):
        super().__init__(application_id='org.nasendackel.Powerpanel')
        self.win   = None
        self.cmds  = {
            'system-suspend.svg':     'systemctl suspend',
            'system-shutdown.svg':    'systemctl poweroff',
            'system-reboot.svg':      'systemctl reboot',
            'system-lock-screen.svg': 'dbus-send --type=method_call --dest=org.gnome.ScreenSaver /org/gnome/ScreenSaver org.gnome.ScreenSaver.Lock',
            'system-log-out.svg':   'gnome-session-quit --no-prompt'
        }

    def do_activate(self):
        self.win = Gtk.ApplicationWindow(application=self)
        self.win.set_default_size(530, 120)
        self.win.set_resizable(False)
        self.win.set_decorated(False)

        esc = Gtk.EventControllerKey()
        esc.connect('key-pressed', self.on_esc)
        self.win.add_controller(esc)

        css = Gtk.CssProvider()
        css.load_from_data(b'''
        window { background: transparent; }
        button {
            background: #1a1a1a;
            border: none;
            outline: none;
            border-radius:12px;
            border:1px solid #fff;
            }
        button:focus { background: #A51D2D; }
        ''')
        display = Gdk.Display.get_default()
        Gtk.StyleContext.add_provider_for_display(
            display, css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)

        box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=20)
        for name in ['system-suspend.svg','system-shutdown.svg','system-reboot.svg',
                     'system-lock-screen.svg','system-log-out.svg']:
            pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
                        os.path.join(ICON_DIR, name), 120, 120, True)
            texture = Gdk.Texture.new_for_pixbuf(pixbuf)
            picture = Gtk.Picture.new_for_paintable(texture)
            picture.set_can_shrink(True)
            btn = Gtk.Button()
            btn.set_child(picture)
            btn.set_size_request(120,80)
            btn.connect('clicked', self.on_clicked, self.cmds[name])
            box.append(btn)
        self.win.set_child(box)
        self.win.present()

    def on_esc(self, ctrl, keyval, keycode, state):
        if keyval == Gdk.KEY_Escape:
            self.quit()
            return Gdk.EVENT_STOP
        return Gdk.EVENT_PROPAGATE

    def on_clicked(self, btn, cmd):
        subprocess.Popen(cmd, shell=True)
        self.quit()

if __name__ == '__main__':
    PowerPanel().run()

After experiencing some issues with openSUSE tumbleweed and only being able to install Niri with a minor fix, I realized that rolling releases are not for me. At present, Niri is still not fixed in openSUSE (as of September 13, 2025, 28 days ago), and the current release has not yet appeared in openSUSE.

My solution to this problem doesn't make any sense at all, but it makes me very happy at the moment: Debian 13 and GNOME.

Right now, I'm looking for stability, and what could be better than Debian? Plus, we've hit the sweet spot with Debian 13 just coming out. So don't ask me in six months if I'm still this happy.

What's so great about Debian? It runs without any problems, whether on my desktop or my Framework 12. All codecs are included, and all my apps are there too (otherwise there's Flathub)...

But why Gnome and no more Tiling Window Manager? I can't say exactly, and I'm not completely done with keyboard shortcuts yet. But you can also configure a lot of stuff in GNOME

More on that later, for sure.

We had a great pleasure to meet Ivan, the main developer of Niri. Niri is a tilling window manager for Wayland, where the user interface is not new, but Ivan is constantly expanding the concept with great interesting possibilities and functions. With the effect that the fan community is getting bigger and bigger.

In the interview together with our guest Christian, we were able to ask few questions to emphasize the aspect of what it means to be an independent open source software developer in addition to the technology discussions.

The first idea was that this interview should be part of our next regular episode. But Christoph also had the idea of separating it to reach English-speaking listeners as well, rather than just our German listeners. And this is the reason for this special.

We recorded our interview outside on the terrace in beautiful weather. However, a bad weather front kept us very busy until the end. The effect was that we were accompanied by twittering of birds and strong rain and wind noises. But that didn't affect the interview in any way. Gordon would say we had atmosphere 😀.

So be part of what we think is an interesting interview and have fun to listening.

It was an exciting interview for me as a Niri user. You can find the interview at Trommelspeicher or on the Triumvirat podcast in all podcast directories.

A what? What is a scrollable-tiling compositor?

The beauty of Linux is the choice. You are not restricted to just one distribution, but also not restricted to one user interface. KDE or Gnome are certainly well known and there is a dispute as to which is the best interface. Then there is sway or Hyprland for the keyboard enthusiasts.

After using sway for a while, I have now discovered Niri.

Niri is a scrollable-tiling Wayland compositor written in Rust. In my opinion, the relatively young system (the first release is from March 2024) is already very stable.

What does that mean? Well, let me quote Niri's github page:

Windows are arranged in columns on an infinite strip going to the right. Opening a new window never causes existing windows to resize. Every monitor has its own separate window strip. Windows can never “overflow” onto an adjacent monitor. Workspaces are dynamic and arranged vertically. Every monitor has an independent set of workspaces, and there's always one empty workspace present all the way down. The workspace arrangement is preserved across disconnecting and connecting monitors where it makes sense. When a monitor disconnects, its workspaces will move to another monitor, but upon reconnection they will move back to the original monitor.

My personal highlights in Niri from the perspective of a non-professional Linux user:

• stability
• fractual scaling with beautiful font rendering
• simple configuration file
• helpful community ( including via Matrix)

Basically, however, I particularly like the approach that apps on each workspace are located next to each other as a band and the width of the apps can be customised. This is extremely practical for working with two or three apps in parallel. The width can be quickly adjusted using a key combination. Very clearly structured.

A screenshot tool is also built in and I can also hide windows via a rule for screencasts. X programme (like Steam) run wonderfully via xsatellite, waybar already has modules for Niri ... so the future looks good.

After some Linux distro hopping (Fedora, Debian) I finally came back to the distro with which I had my first Linux experiences in the mid-90s: openSUSE. I have to say, a lot has happened during this time and I am particularly fond of the rolling release Tumbleweed.

Tumbleweed is a rolling release distro, i.e. there are no versions. The system updates itself constantly. What is different with tumbleweed, however, is that new packages are first run through a test system and then published as a snapshot.

Speaking of snapshots: After each installation, the system automatically creates a snapshot and if something goes wrong ... simply revert to a previous version.

This brings stability, but also always very up-to-date packages.

Basically, I have also found (almost) no software that is not available for tumbleweed. This means that I have not yet needed to install anything via Flatpak.

So no problem to use a release candidate of Gimp 3 or Gnome 47. But smaller and newer projects such as Niri are also quickly installed.

Thus: I could also rename this blog ‘in love with opensuse’. I am so very enthusiastic and actually a little bit in love.