DEV Community: svhl

Spoofing terminal screenshots

svhl — Sun, 01 Feb 2026 03:30:00 +0000

r/unixporn is a popular subreddit for sharing screenshots of your Linux rice. It also acts as a hardware and software survey, by letting everyone know your computer's specs and your workflow. If you don't want to make this information public, you can always spoof it.

This is a screenshot of my own rice. However, the programs, the specs, the music library... they're all fake. I'll break down how you can spoof each of these components below.

Application icons

For a new application, create a file called [application_name].desktop at ~/.local/share/applications. For example, let's create a file for Firefox. Add the snippet below to firefox.desktop.

[Desktop Entry]
Icon=firefox
Name=Firefox

The Icon parameter should be a valid icon name from your icon theme. If you want a custom image as the icon, provide the path to the image instead.

Obviously, you can't launch this since there isn't an Exec parameter, but we can use this method to populate the taskbar without needing to actually install these programs.

Neofetch

This is a terminal utility to display system information about your computer. Conveniently, it also allows you to set custom output in its config file located at ~/.config/neofetch/config.conf.

To change the ASCII art, set a distro name in the ascii_distro variable. A list of valid distros are provided in the comments above the variable. For example, to set the Debian logo,

ascii_distro="debian"

To change the text regarding hardware and software information, comment out the necessary lines, and set custom output using prin commands. In my case, I set a custom title, OS, and host using the below snippet.

#info title
prin "$(color 1)kde$(color 255)@$(color 1)optiplex"

#info "OS" distro
#info "Host" model
prin "$(color 1)OS: Debian GNU/Linux 13 (trixie) x86_64"
prin "$(color 1)Host: OptiPlex 7080"

Music library

If you want to showcase your custom CLI music player rice, but don't want others to know your music taste, use MusicFakez. Provide an album name to generate empty songs filled with silence, complete with metadata, to make others believe you actually listen to them. This saves your bandwidth by not actually downloading the songs, just faking it.

To use the tool, make sure Python and FFmpeg are installed first. Then, run

git clone https://github.com/svhl/musicfakez
cd musicfakez
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python3 musicfakez.py

That's it!

Now you no longer have to pretend your Manjaro rice is Arch. You can just gaslight people into believing it is.

The better way to shorten Linux commands (it's not alias)

svhl — Sat, 13 Dec 2025 03:30:00 +0000

alias apup='sudo apt update'
alias apug='sudo apt upgrade'
alias apls='apt list'
alias apsr='apt search'

If you're a new Linux user, you might have a ~/.bash_aliases like this. Aliases are useful when you want to shorten lengthy commands, but aliasing like this isn't the best method for a few reasons.

Why not alias?

Too many aliases mess with autocompletion

In most Linux shells, pressing the tab key when typing out a command shows autocompletion suggestions. However, too many aliases beginning with the same prefix can clutter up these suggestions.

user@host:~$ ap
apls                    apsr
apt                     apug
apt-add-repository      apup
apt-cache               apt-get
aptitude                apt-mark
user@host:~$ ap

Aliases don't support taking parameters

Sure, aliases allow arguments at the end of the expanded command, but not in between the command. This limits the kinds of commands that can be shortened using an alias. Hence, ffmpeg or magick can't be shortened this way since they take arguments for an input as well as output file.

Aliases hide the command's syntax

alias gtad='git add .'
alias gtcm='git commit -m '
alias gtps='git push origin main'

Aliases like these prevent you from learning the actual command's structure. For example, to commit only a specific file, gtad won't work, so you'll have to type out the whole command anyway. In such cases where the hardcoded arguments may change, learning the actual command is better than aliasing it and forgetting it.

When should you alias?

alias sql='sudo mysql -u root -p'

This is a good example of an alias. Once you've set up MySQL, you'll only ever use the command to login to the interactive shell. ~/.bashrc by default also contains some useful aliases like

alias la='ls -A'

However, sql alias is still a bit restrictive, since the username is hardcoded. These limitations can be addressed with...

Wrapper scripts!

These provide the complete flexibility of Bash (or whatever shell you're using). You can read parameters, perform operations within the script, and much more.

Let's take Git for example. You might always run certain commands with fixed parameters, such as using your token to connect to a Git repo. A wrapper script could be used to simplify this.

Create a script at ~/.local/bin. Don't forget to set GIT_TOKEN in ~/.bashrc or somewhere else. This way, such variables are kept in one place, making them easy to modify if needed.

#!/bin/bash

if [ $1 == "sync" ]; then
    /usr/bin/git remote set-url origin https://$GIT_TOKEN@github.com/$2
# one more thing...

To make this wrapper script seem seamless, we can even change its name to git. This overrides the Git binary in /usr/bin. Add an else statement to let it handle all other parameters as usual.

# add this as well
else
    /usr/bin/git "$@"
fi

Now, to connect to a repo, just type

git sync [github_username]/[repo_name]

These scripts can also be modified to match the structure of the other commands of the package (for example, choosing between sync, -sync, or -s depending on if it's git, magick, or yt-dlp).

(Btw, if you wanna see more of my Git wrapper scripts, check them out here!)

Is copy-pasting from the clipboard in Vim broken for you on Wayland?

svhl — Sat, 29 Nov 2025 03:30:00 +0000

Vim uses registers to store copied text and paste from, rather than the system clipboard. When copy-pasting from another app, this isn't ideal, since the clipboard is inaccessible within Vim.

To avoid this, the clipboard flag needs to be set. To check it, run

$ vim --version

This output contains all the flags that are set. If you see +clipboard, you're good. Otherwise, you'll have to recompile Vim with this flag, but the easier solution would be to additionally install vim-gtk3.

Then, add

set clipboard=unnamedplus

to your ~/.vimrc.

The problem

The above solution used to work on X11, but it only partially works on Wayland.

Yanking text copies it to the clipboard, but pasting still uses Vim's internal register. Even explicitly pasting from the clipboard register with "+p doesn't work.

If you are also facing this issue, check whether wayland and wayland_clipboard flags are set. If they aren't present, clipboard functionality wont properly.

The solution

This solution is meant for KDE Plasma, since it uses qdbus. An alternative solution is also provided below.

The output of

$ qdbus6 org.kde.klipper /klipper getClipboardContents

shows the last copied clipboard content followed by a line break. We could just directly use this command via command-line mode in Vim, but the trailing newline causes problems. When pasting the same text multiple times, these unnecessary line breaks add up in between.

To avoid this, a custom script can be utilized to format the output. Within /usr/bin, create a script called kpaste.

#!/bin/bash

REAL_USER="${SUDO_USER:-$(logname)}"
REAL_UID=$(id -u "$REAL_USER")
DBUS_ADDR="unix:path=/run/user/$REAL_UID/bus"

if [ "$EUID" -eq 0 ]; then
    exec sudo -u "$REAL_USER" DBUS_SESSION_BUS_ADDRESS="$DBUS_ADDR" "$0"
fi

echo -n "$(qdbus6 org.kde.klipper /klipper getClipboardContents)"

Only the last line is required if the script is run as a regular user, but if we're editing a file as sudo (via sudo -E vim), the script won't work since root doesn't have access to the user's clipboard.

Therefore, we obtain the current user's name (REAL_USER), which is used to find their UID (REAL_UID), which finally allows us to connect to their DBus (DBUS_ADDR).

If the script is run as sudo, then call it again as the current user. Otherwise, call the clipboard normally.

Make it executable with

$ chmod +x /usr/bin/kpaste

Now, add the below line to ~/.vimrc to remap in normal mode.

nnoremap p :let @0=system("kpaste")<CR>"0gp

So what does it do?

nnoremap p: Assign a custom mapping to p in normal mode.

:let @0=system("kpaste")<CR>: Copy the output of kpaste to Vim's clipboard register "0 (which is the register for the yank operation, though you can also use any other register).

"0gp: Paste from the clipboard register after the cursor. If using just "0p, pasting text that contains line breaks would place the cursor at the beginning of the pasted text, rather than at the end as expected. To avoid this, we use "0gp.

To remap in visual mode,

vnoremap p :<C-U>let @0 = system("kpaste")<CR>gv"_d"0gp

In addition to the above explanation,

:<C-U>: Removes the visual range '<,'> so :let works.

gv: Reselect the previous selection.

"_d: Delete into the black hole register.

This also pastes after the cursor. To paste before the cursor, replace p with P in the above mappings.

This restores complete clipboard functionality!

Alternative solution

If you're not on Plasma, install wl-clipboard. This package provides the command wl-paste, which pastes the last copied item from the clipboard. As mentioned above, create an additional script that echoes the output without a newline, and remap p correspondingly.

However, I wouldn't recommend this method, since the output when the clipboard is empty is

$ wl-paste
Nothing is copied

This causes the text "Nothing is copied" to be pasted into Vim. An additional check would be needed to output nothing in this situation.

Understanding Linux distros (and how to pick one)

svhl — Sat, 22 Nov 2025 03:30:00 +0000

"Top 10 distros for gaming"
"The BEST Linux distro for developers"
"The best distro of 2025"

These are the type of articles that show up when you're a new user trying to switch to Linux. Most of the time, such articles don't make the distinction between distros clear enough that users can compare them. This article aims to break down the basic components that make up a Linux distro, and see how popular distros differ in these aspects.

What makes a distro

While there are lots of components that shape a distro, I'll be focusing on the main ones that matter to a new user:

desktop environment
package manager
package freshness
display server

Desktop environment

This is the "frontend" of the distro. It's the GUI components that you interact with, such as the taskbar, the window decorations, the tab switcher, and so on. Most desktop environments can be classified as either Qt or GTK-based.

When picking a distro, go for one that has a live environment. This means that you can try it out before installing. This lets you experiment with the DE, and if you don't like it, easily switch to a different distro.

Qt-based DE

KDE Plasma is known for being Windows-like out of the box, so Windows users will find it very easy to transition.

Configuring various settings like animations, the taskbar, themes, and so on may seem overwhelming due to the amount of control provided to the user. Due to this, Plasma is relatively buggier compared to the other distros. This is simply because more options for configuration = more points for failure = more bugs.

However, it's also the most customizable. In addition to the inbuilt themes, you can download new ones to change the colors, the cursor, and much more. If you aren't afraid to tinker and you've got the time, you can tune Plasma to fit your workflow or aesthetics.

GTK-based DE

They are known for being more rigid by providing less settings for the user to modify. GNOME and Cinnamon are two popular examples.

GNOME looks similar to macOS, while still having its own unique workflow. Its looks depends on the distro, as distro maintainers often customize it, unlike Plasma which usually looks the same everywhere by default. Here's how GNOME looks on Ubuntu...

...and here's vanilla GNOME on Fedora.

Notice how in the first one, the taskbar is always visible, while in the second one, you have to enter the mission control-like view to see it. Even though you can customize a few things like this using extensions, GNOME still expects you to use it in the "GNOME way".

Hence, these extensions can sometimes feel like an afterthought. For example, the clipboard in Plasma shows up right below your cursor for easy access, and passwords copied from a password manager don't show up in the clipboard. GNOME doesn't come with a clipboard by default, and third-party ones don't have the above features.

If you aren't a power user, are comfortable with adapting to something new, and just want a DE that looks good with basic functionality, GNOME is a solid option.

Cinnamon is another option if you'd rather have a Windows-looking DE. While it has less customizability than Plasma, it's more stable. Again, if you're fine with a reasonable level of customization, go for it.

Whatever the DE, preferably stick to apps that use its framework. In the above images, you'll see that the window decorations of apps on KDE all look the same, but that of the file manager and Firefox on Fedora GNOME look similar, but aren't the same. If you try to use a KDE app on GNOME, or vice-versa, the theming and style will be different. Further complicating this, different versions of GTK, like GTK3 and GTK4/Libadwaita, are also styled differently.

Remember that KDE apps are also more feature-rich, while GNOME apps are simple to use. Unfortunately, the moment you step out of the GTK4 ecosystem on GNOME desktop, the feeling of cohesion breaks. Apps don't look how they were meant to look, unlike on Plasma. Combining this with the issues caused by Wayland mentioned below, this may be a deal-breaker.

Package manager

A package manager is how you download and update software. Different families of distros will use different package managers.

APT

This is used by Debian-based distros such as Ubuntu, Mint, and Debian. If you're getting started with Linux, I'd recommend this, as most support threads on installing software deal with APT.

DNF

Red Hat-based distros like Fedora use this on the other hand. For an end user, the only real difference is the syntax. Perhaps sometimes, you might find a package with only a .deb version, but if you mostly use GUI apps, I wouldn't worry about it too much because of...

Flatpak

It's a universal GUI package manager available on every distro. There's no need to type your root password when installing, updating or deleting, unlike the others mentioned above. Additionally, you can use Flatseal to manage permissions like file access, network access, and so on per app for better security. This is in contrast to native package managers which give all apps all permissions, regardless of whether they need them or not.

Oh, also Ubuntu comes with Snap, which is their implementation of a universal package manager. Unlike Flatpak, it doesn't manage permissions as intuitively, and apps are known to take longer to start up. Preferably, use Flatpaks instead of Snaps.

Package freshness

This refers to how new the packages are in the repositories. Newer packages will have more features, but also potentially more bugs, while older packages are the opposite.

Debian only provides feature updates every 2 years, so packages can become very stale. Hence, it's recommended for servers rather than everyday users. However, Debian-based distros like Ubuntu and Mint come with newer packages. I'd also suggest going with Ubuntu's non-LTS version with a release cycle every 6 months, rather than the LTS that only upgrades every 2 years.

Fedora moves faster than Ubuntu even though its release cycle is also 6 months. This means that it will be the first to adopt new technologies like switching from Xorg to Wayland, though such changes may affect your workflow. More on this in the section below.

Flatpaks update whenever the developer releases a new version, similar to how updates work on iOS and Android. Even if an update breaks an app, you can easily revert to a previous version without uninstalling and reinstalling. Therefore, use native packages for system apps, and Flatpak for other GUI apps.

You'll notice that I haven't mentioned Arch-based distros like Manjaro and Arch. This is because these are rolling-release distros, meaning they have a higher chance of breaking. Non-system apps breaking is just an annoyance, since you can rollback, but the system breaking or not booting can lead to hours of troubleshooting. That's why I'd suggest going for a more stable distro instead.

Display server

A display server is responsible for rendering content on your screen, processing inputs, and so on. Your distro will either be Xorg/X11 or Wayland-based.

Wayland

This is the modern replacement for Xorg. It comes with many features such as HDR support and allowing different scaling for multiple monitor setups, which are not provided by Xorg. Hence, try out the Wayland version of a distro first, and switch to Xorg if there are any graphical issues such as glitches or artifacts.

Wayland, specifically on GNOME, may have issues with fractional scaling causing blurry windows, text being too small, or inconsistent window maximizing behavior. Windows decorations too may follow the incorrect color theme, or just look... wrong, because of how GNOME implements them. Additionally, some apps are built for X11, but they can run on Wayland under Xwayland. However, you may lose drag-and-drop support for them.

Xorg

This is an archaic implementation compared to Wayland, but unless you need the above mentioned features or your hardware doesn't work well with Wayland, it's a fine option. Do note that you may face issues like...

...this. Screen tearing occurs when you try to move a window or play a video on Xorg, causing the display to look like it got shredded. A compositor comes with your DE to prevent this, but if you're gaming, you'll have to disable the compositor to get higher FPS. Screen tearing won't appear in gameplay, but it will show up in pre-rendered cutscenes.

A heads-up that GNOME will be dropping Wayland support soon, so if you want an Xorg-based DE, go with Plasma or Cinnamon.

What are your options?

Here are the distros I'd recommend in no particular order. If you skipped to this section, please read the above, as otherwise this would just be another "the best Linux distro" article.

Linux Mint

Mint corrects all the fuck ups of Ubuntu so you don't have to do it yourself. It ships with Cinnamon, which is built by the Mint team, along with two other DEs. Unless your device is really potato, go with Cinnamon. Its Wayland session isn't as mature as the other distros, but in case you do face issues, the Xorg session is always as option. Because it's built upon Ubuntu LTS, it doesn't come with the latest kernels, libraries, and so on. Unless you're a non-casual gamer or have the latest hardware, this is a good beginner's choice.

Ubuntu

If you decide to go with Ubuntu instead, go for the non-LTS release. You'll have to deal with disabling Snaps yourself, but you get a balance of not too old and not too new software. It also has a GNOME and a Plasma version (called Kubuntu), along with good support for Wayland.

Fedora

Flatpaks provide better package management compared to Ubuntu's Snaps, and you'll get newer software from the native repos. Just note that they'll also be the first to drop support for "older" software, but in that case, you can stick to the previous release until you're ready to transition since Fedora offers over a year of support.

Other distros such as Zorin and Pop!_OS are just different combinations of the above factors. Just make sure the distro you choose meet your software, hardware, and time-you're-willing-to-spend-on-it requirements before installing!

Dolphin switches from .directory to extended attributes

svhl — Sat, 25 Oct 2025 03:30:00 +0000

When I upgraded from Debian 12 to 13, KDE also transitioned from Plasma 5 to 6. That's when I noticed that there were no longer .directory files in Dolphin, KDE's file manager.

Previously, when you set "Remember display style for each folder" in Dolphin and change the display style for a particular folder, a .directory file will be created in that folder. This file stores the view mode (icons, compact or details), and other attributes such as whether to show hidden files.

Since this is on a per-folder basis, a .directory file will be created for each folder you change the display style for. While this approach works, it's not an ideal solution as it pollutes your file system with unnecessary files. This is similar to how macOS creates .DS_Store files.

I guess one solution would be to keep track of this information in a database instead. An issue with this is that when a user deletes a folder outside of Dolphin, the corresponding attributes entry in the database should also be removed. Otherwise, these invalid entries will take up unnecessary space over time. This requires too much overhead, so it's not feasible.

The solution

A better method would be to embed these attributes within the folder so that it's not visible to the user. Using a tool like getfattr, we can view these extended file attributes.

First, install it with

$ sudo apt install fattr

Then, change the display style in a folder and run the below command. You'll notice that KDE has created an extended attribute.

$ getfattr ./
# file: . user.kde.fm.viewproperties#1

To view the value of this attribute, run the below command

$ getfattr -d ./
# file: . user.kde.fm.viewproperties#1="[Dolphin]\012Timestamp=2025,10,24,11,06,34.929\012Version=4\012ViewMode=2\012"

In my case, ViewMode will be set to 2, since I changed the display style to compact view mode. Details view mode will show 1 and icons view mode will show 3 instead.

Now, I'll set to show hidden files and run the command again. Notice how HiddenFilesShown is set to true.

$ getfattr -d ./
# file: . user.kde.fm.viewproperties#1="[Dolphin]\012Timestamp=2025,10,24,11,06,45.362\012Version=4\012ViewMode=2\012\012[Settings]\012HiddenFilesShown=true\012"

However, custom folder icons are still stored in .directory files, but that might be changed soon. Nevertheless, this is a very welcome change in Plasma 6. I hope other file managers like Nautilus also implement such solutions (if GNOME gets around to implementing per-folder display styles first).

Changing the GRUB boot order in current year

svhl — Wed, 24 Sep 2025 02:45:00 +0000

There are way too many forum posts talking about reordering entries in the GRUB menu. Some methods are too complicated, some don't work anymore, and some people even advise against doing it. Here's the simplest method I've found so you don't have to go through dozens of Google results.

Avoid GRUB Customizer!

Before we begin, I'd suggest steering clear of GRUB Customizer since it can cause issues. Initially, I tried this method, but it created duplicate entries in my GRUB menu. In case your GRUB menu also got messed up, I'll cover how to fix it in the below section as well.

The actual solution

In this example, I am going to move Windows above Linux. Go to /etc/grub.d. You'll see a file called 30_os-prober or something similar in the directory.

$ ls /etc/grub.d/
00_header
05_debian_theme
10_linux
20_linux_xen
20_memtest86+
30_os-prober
40_custom
41_custom
README

You'll also notice two files called 00_header and 05_debian_theme.

00_header sets environmental variables such system file locations, video settings, and previously saved entries.

05_debian_theme sets the GRUB 2 background image, text colors, selection highlighting and themes.

The boot entry after these will show up first in GRUB. Change the number of the os-prober file to change the order. Rename 30_os-prober to something like 09_os-prober, then update GRUB.

$ sudo mv 30_os-prober 09_os-prober
$ sudo update-grub

In case GRUB Customizer created duplicate boot entries, delete those files from this directory. Afterwards, update GRUB like above. That's it! Reboot your system to see the changes.

Test your website on both Firefox and Chromium

svhl — Fri, 14 Mar 2025 06:30:00 +0000

In my previous article Ensure your website is mobile-optimized, I briefly mentioned about testing out your site on Firefox as well as Chromium-based browsers. Almost all mainstream browsers are based on Firefox or Chromium, so by optimizing for both, you can make sure your site is optimized for (almost) all your users.

But why though?

Here is a snippet of code from one of my projects.

h1 {
    transform: translateY(65px);
}

.inputField {
    margin-top: 7px;
    transform: translateY(-67px);
}

button {
    margin-top: 7px;
    transform: translateY(-67px);
}

This code specifies the gap between the heading, input fields, and button. However, this gap is interpreted differently on Firefox and Chromium-based browsers.

Firefox

Chromium

How to fix it

Use different gaps on Firefox and Chromium so they both look identical. Specify the code for Chromium using

@supports (-webkit-appearance: none) {
    /*chromium specific css*/
}

...and for Firefox using

@-moz-document url-prefix() {
    /*firefox specific css*/
}

So in my case, I should modify my code to be

@supports (-webkit-appearance: none) {
    h1 {
        transform: translateY(52px);
    }

    .inputField {
        margin-top: -10px;
        transform: translateY(-62px);
    }

    button {
        margin-top: -10px;
        transform: translateY(-62px);
    }
}

@-moz-document url-prefix() {
    h1 {
        transform: translateY(65px);
    }

    .inputField {
        margin-top: 7px;
        transform: translateY(-67px);
    }

    button {
        margin-top: 7px;
        transform: translateY(-67px);
    }
}

This results in the gap looking similar on both browsers.

Firefox

Chromium

Ensure your website is mobile-optimized

svhl — Thu, 06 Mar 2025 08:00:00 +0000

Making your website responsive is important to ensure that it looks good on a variety of screen sizes, from phones to tablets to desktops. Instead of having to resize your browser window each time to test out different resolutions, here are a few ways to do so with ease.

But first...

...how do you make your site responsive? By using @media in your CSS. For example,

#item {
    width: 50px;
}

@media (max-width: 900px) {
    #item {
        width: 30px;
    }
}

Here, if the width of the viewport is greater than 900px, the width of #item is 50px. But if it is less, the width of #item is 30px. You can also specify different widths for different viewport sizes.

@media (max-width: 500px) {
    #item {
        width: 10px;
    }
}

Test it out

On Firefox-based browsers, use the shortcut ctrl+shift+m to enter responsive design mode.

On Chromium-based browsers, use the shortcut ctrl+shift+i, then ctrl+shift+m to enter device mode.

From the top left dropdown, choose the device you want to emulate. Alternatively, grab the corners or edges of the viewport and resize.

Note that this may not exactly show the behavior of your site on mobile. For example, on my website, I've noticed that the effect that's supposed to happen on hover happens on click on mobile. To see how your site actually behaves on mobile, you'll have to localhost your site and view it on your mobile device, ideally on both Firefox and Chromium.

Open a terminal in your project folder and run

python3 -m http.server

The output will contain the port number. In my case, it's 8000. Next, find your local IP address by running

hostname -I

In my case, it's 10.10.10.10. Access the site on your phone connected to the same network by visiting your local IP address:port number. For me, it will be 10.10.10.10:8000. Remember to ensure your desktop firewall allows incoming traffic for the site to be accessible by another device!

Some useful Git commands

svhl — Thu, 27 Feb 2025 05:00:00 +0000

Git is an essential tool in every developer's workflow. This article covers a few common (and not so common) Git commands. Some of these are specific to GitHub, so make the necessary changes if you're using a different platform like GitLab.

I've also provided a wrapper script here that shortens the commands for ease of use. Download the script to ~/.local/bin. A few changes need to be made to the script, which will be mentioned below.

Clone repo

Using Git

git clone https://github.com/[user]/[repo] --branch [branch]

Using script

git copy [user]/[repo] [branch]

Clones the specified branch of the user's GitHub repo to your local machine. If you want to clone the default branch (usually main or master), the branch argument isn't necessary.

Set remote repo

Using Git

git remote set-url origin https://[token]@github.com/[user]/[repo]

Using script

git sync [user]/[repo]

Since "support for password authentication was removed" on GitHub, you'll need to use a token in order to commit. From GitHub, go to Settings > Developer settings > Personal access tokens > Tokens (classic) to create a new token. From the dropdown, select Generate new token (classic), set the parameters, and hit Generate token.

Set the token to commit to the user's repo. If you're using the script, set the TOKEN variable within the script.

Undo last commit

Using Git

git reset --hard HEAD~1
git push origin HEAD --force

Using script

git undo

Revert to the state before the last commit. Requires you to be authorized to do so.

One more thing...

Here's how to properly commit via Git.

git config --global [username]
git config --global [email]

where [email] is your noreply email address found on GitHub at Settings > Emails.

Then, generate a new GPG key.

gpg --full-generate-key

When prompted, use the defaults. Set username and email, and also a password (this will only be stored locally).

Run the below command and copy the GPG key ID.

$ gpg --list-secret-keys --keyid-format=long
/Users/hubot/.gnupg/secring.gpg
------------------------------------
sec   4096R/3AA5C34371567BD2 2016-03-10 [expires: 2017-03-10]
uid                          Hubot <hubot@example.com>
ssb   4096R/4BB6D45482678BE3 2016-03-10

In this case, the [id] is 3AA5C34371567BD2. Next, run

gpg --armor --export [id]

Copy your GPG key, beginning with -----BEGIN PGP PUBLIC KEY BLOCK----- and ending with -----END PGP PUBLIC KEY BLOCK-----.

To add this key to your GitHub account, go to Settings > SSH and GPG keys > New GPG key. In the key field, paste the above copied text.

Finally, to always sign commits, run the below commands.

git config --global commit.gpgsign true
git config --global user.signingkey [id]

Daily driving Debian 12 in 2025

svhl — Fri, 21 Feb 2025 06:15:00 +0000

Debian may seem like the least suitable distro for the desktop, but it doesn't have to be that way. Debian receives critical security updates, so the only thing you're missing out is on feature updates (and fixes for a few annoying, but not deal-breaking bugs).

Still, there are many ways to use newer packages on Debian Bookworm. Below are some of them, ordered from most preferred to least preferred in my opinion.

Additional repos

This involves adding custom repos to your APT sources. Programs like Firefox and Wine support this. Some of these have a separate .sources for Debian Stable, so you can be sure you won't get any missing dependency issues.

Also, programs like Steam and Chrome only require you to install the .deb package they provide, and the sources also get added automatically.

.deb packages

This method may not handle updates via APT like above. Useful if you want a specific version of the package, most likely when the package provided by Debian is too old but the latest package causes dependency issues. However, some programs like Obsidian handles updates within the app by checking for updates every time the app starts, which breaks the all-in-one package updater aspect of a package manager.

Flatpak

This allows you to obtain the latest version (or a specific version) of a package easily. You may sometimes face theming issues, but usually you can easily fix it by allowing access to the necessary directories using Flatseal. Another advantage of Flatseal is that it's easy to set permissions and environment variables, compared to editing the .desktop file manually.

Since Flatpak apps are independent of each other, it's difficult to integrate one program with another. For example, you can open the current directory in a terminal from within Dolphin. By default, the terminal emulator is Konsole, but you can change it in the ~/.config/kdeglobals file. However, changing it isn't possible in the Flatpak version of Dolphin.

Flatpaks also update independently from native packages, so you'll need to set up a service for automatic updates, or remember to update manually.

AppImage

Like Flatpaks, but more difficult to theme and could take up more space. Sometimes, this may be the only option for download, or you might want to keep a program around whose development has been discontinued, like Yuzu. You can view a list of popular AppImages here.

Building from source

This method can be difficult due to old dependency issues. Most GUI programs will be available from one of the sources above, but some utilities like gtk3-nocsd will require building from source.

Debian Testing or Unstable

These are other flavors of Debian that come with newer packages. However, I've noticed that they're not as stable (especially Plasma and KDE software). I'd recommend sticking with Stable and using one of the methods above instead.

Some useful Linux command-line launch arguments

svhl — Sun, 16 Feb 2025 06:30:00 +0000

Command-line arguments can be added before you call a program in Linux. They can be used to pass parameters to the program, set or unset environment variables, or even run "wrapper programs" before launching your program.

How to use

If you're calling the program from the terminal, you can add an alias like

alias [program]=[args] [program]

If you're calling from an app launcher, you can modify the .desktop file. The file will probably be present at /usr/share/applications/. Copy it to ~/.local/share/applications/ so you can edit it without root.

Now, modify the Exec parameter to be

Exec=env [args] [program]

Below are a few arguments that I use.

Prevent internet access

firejail --noprofile --net=none

Prevents the program from having internet access. Requires Firejail to be installed.

Use GTK file picker

QT_QPA_PLATFORMTHEME=gtk3

On Qt desktops, use the standard GTK file picker instead of the one that came with the program. Useful if the file picker can't adapt to the color scheme resulting in incorrect symbolic icon colors.

Scale program fractionally

QT_SCREEN_SCALE_FACTORS=""

Make the program scale properly if fractional scaling is used. Otherwise, the fonts and images would look blurry. Additionally, by specifying a decimal value >1 within the quotes, you can scale it up.

Better touchpad on Firefox

MOZ_USE_XINPUT2=1

Use kinetic scrolling and touchpad gestures in Firefox on Xorg.

Pre/Post-launch game scripts

gamemoderun

Activates GameMode with your configuration when you run a game (use it as a start/stop script if activing GameMode when starting the game does not work in your game launcher). Useful if you want to disable/enable the compositor when the game launches/closes on Xorg, or something similar.

I'll update this post (hopefully) if I find more!

Make non-Qt apps look native on Qt desktops

svhl — Sat, 08 Feb 2025 06:04:24 +0000

Update: There's a newer (and better) method to theme not just GTK3 apps, but also GTK4/Libadwaita. Check out GTK-NoCSD by MorsMortium, which is actively maintained with consistent improvements.

Theming non-Qt apps is essential on Qt desktops like KDE Plasma or LXQt if you don't want them to stick out. How easy it is to do depends on the GTK version the app uses.

This is a guide for Lutris, but it should work for any other GTK3 app.

How to do it

First, install gtk3-nocsd from GitHub.

The latest release is outdated, so don't use it. Instead, clone the repo, install dependencies and build according to the instructions mentioned on GitHub.

This is enough to remove the CSD, but there are still a few issues.

A thin line spanning underneath the titlebar

Some titles and buttons are duplicated

To solve these, edit your ~/.config/gtk-3.0/gtk.css file and add the lines below.

decoration, decoration:backdrop {
    box-shadow: none;
}
.title {
    color: transparent;
}
.titlebar,
.titlebar .background,
decoration,
window,
window.background {
    border-radius: 0;
    border: 0px;
    box-shadow: none;
}

Also, remove the url content of the first three lines of ~/.config/gtk-3.0/window_decorations.css. This won't remove the close button, but it will make it invisible.

headerbar button.titlebutton.close, .titlebar button.titlebutton.close {
  background-image: url(""); }

headerbar button.titlebutton.close:hover, .titlebar button.titlebutton.close:hover {
  background-image: url(""); }

headerbar button.titlebutton.close:active, .titlebar button.titlebutton.close:active {
  background-image: url(""); }

The changes in this file will get reverted, so make the file immutable by running

sudo chattr +i ~/.config/gtk-3.0/window_decorations.css

The Qtfication is now complete!