2023-08-18

Today I want to talk a bit about configuration files as well as their issues, and believe me, there are many issue with configuration files.

The suckless approach

The suckless approach for those unaware is to never use config files. Instead, with suckless software you modify a config.h header which contains variables intentionally exposed to the user. Then you simply rebuild the software with the options chosen built into the binary.

Many issues with regular configuration files are not a problem here. We'll get into those problems in a bit, but doing it this way introduces many other potential problems. The most notable issue is having to recompile the program every time you want to change one small thing, such as the colorscheme or a keybind.

In any case, most of the problems with regular configuration files do not apply to suckless software, simply because of how it is designed.

Problems with configuration files

• Options get deprecated

This is what compelled me to write this blog post. Although not a problem with configuration files directly, developers naturally often feel the need to deprecate options in their configuration files, but this is incredibly poorly handled most of the time leaving the user suffering.

Let's take Hyprland for instance. Hyprland wants to be this compositor which always implements the latest and greatest, and as a result they do not at all care if they drop support for options the user has in his or her configuration file. After updating Hyprland I received a warning because I had used a now deprecated option in my configuration file. This option is simply a toggle for blur.

A sensible developer would deprecate the feature and in case a replacement exists, simply rewrite the user's config file on runtime to use the new replacement. As a result, the user can use the old configuration file with the new program and everyone is happy. If a replacement option does not exist, you should probably simply ignore the line. In the rare case that a option MUST be removed, the major version should be bumped and users should be warned in advance.

A general rule is, if the configuration works right now, it should work in 10 or 20 years with almost no maintainence necessary. This is one area where suckless software rocks. For the record, I can compile dwm 0.1 from July 2006 on my computer and it will work EXACTLY like it did in 2006. No maintainence necessary.

• Not very extensible

Configuration files are not very extensible most of the time. Some config files are more hackable than others, but usually they simply modify variables in the program itself and nothing more, so writing new code or new functions is usually not at all trivial and config files usually are not designed around being hackable.

Some config files kind of support functions or similar, notably Waybar.

• Syntax

The syntax can vary. Some programs use Windows style .ini files which look something like this:

[myProgram]
Variable = 123

While these aren't extensible at all, they make up for that in simplicity, which is very often desirable, especially if you don't need the program to be that extensible through a config file. But of course, this format isn't good for every single use case, so JSON style formats such as YAML are very popular.

That's where the syntax can be a problem. The syntax is usually very unpredictable and unless a "default" configuration is bundled with the program the user is likely to be very lost. To make matters even worse, the default configuration is usually hidden away so the user ends up having to use the internet to figure it out.

Conclusion

Alright, so what do I think about configuration files? Contrary to what you might think, I am not against config files, at least not most of the time. I even use configuration files in a lot of my software.

However it's worth noting that config files are not without problems, and while a good developer can work around some of these issues, for example by simply not deprecating features like a madman, at the end of the day a config file is written after the program was initially compiled, and that's a big reason for all of its drawbacks.

That's it for today, have a good day!

2023-07-16

Today I'm going to talk about some dumb things people do in shell scripting, and I'm also going to tell you a better way to do it, as well as a cool trick.

Don't use echo

echo seems simple right? echo Hello World! will print out 'Hello World!' to standard output. Despite being such a simple command and likely one of the first UNIX programs you interact with, echo is garbage.

The main reason you should not be using echo is because the way it works will differ depending on your operating system. For instance, echo -e on Arch Linux will interpret backslash escapes such as newlines, however on other distributions like Gentoo, -e is intepreted as text.

So on some systems, echo -e 'Install Gentoo\n' will result in 'Install Gentoo' being printed and on others it will result in ' -e Install Gentoo' being printed. In short, the reason echo sucks is because it does not work the same on all operating systems.

What should I use then, you might say. The answer is use printf. printf is designed to print more complex text, and can do way more than echo can. The first difference you're likely going to notice if you've been using echo is printf does not append a \n newline character. This means

printf "a"
printf "b"
printf "c"

will result in 'abc' being printed. Of course, the solution is to just append \n to the text you're printing. So printf 'Hello world\!\n will result in the same thing as echo 'Hello world\!'.

If you're a C or maybe C++ programmer, you're likely already very familiar with printf and related functions, and the core utility works almost exactly the same.

Do not do something like printf "$MyVar" though. That's incorrect usage of printf even though it does technically work. The correct way to use printf with variables is printf 'MyVar1: %s\nMyVar2: %s\n' "$MyVar1" "$MyVar2". %s here means string, but if you have an integer, you can use %d. It is pretty safe to use %s for everything though, because you don't really have different data types in shell scripting.

Mostly useless Bash-isms

The Bash shell provides notable useful features, such as arrays. This is a valid use case for Bash. Sometimes using Bash will increase speed because of these features.

But when people are new to shell scripting, they tend to overcomplicate things, and that can result in big problems. I'm guilty of this as well, which is why I'm telling you this. Let's say you want to check if $DISPLAY is defined or not. You know, to check if X or Wayland is used. The brainlet way to do this would be something like this:

if [[ -n "$DISPLAY" ]]; then
    x=true
fi

This does work in case you are using Bash, but it is really ugly. You should write POSIX compliant shell scripts unless you depend on a Bash feature which simply cannot be had with POSIX sh. This is the most useless use of Bash I can think of. In order to make this POSIX compliant, you could do this:

if [ -n "$DISPLAY" ]; then
    x = true
fi

Yep, it's that simple. Using an if statement here at all is dumb too, though but not as bad. The good way to do this is simply [ -n "$DISPLAY" ] && x=true. The worst I've seen (and done) is when people use Bash-isms and then proceed to put #!/bin/sh or #!/usr/bin/env sh at the top. At first glance, it may appear to work just fine. This is likely because /bin/bash is a symlink to /usr/bin/bash and so Bash is used anyway. If the user is using a strictly POSIX compliant shell like Dash instead, the script will not run properly. If you write bash scripts, you should put #!/bin/bash or #!/usr/bin/env bash at the top, so that Bash specifically interprets the script.

Another almost completely useless Bash feature is source. It is nearly identical to the POSIX compliant . which simply loads functions and variables from a file. Refrain from using source even when writing Bash scripts though, because it's completely unnecessary and a bad habit.

Loading in functions when necessary

This is not something bad people do but rather something I've found very useful. If you have a big script, having to read a bunch of functions every time the script is being interpreted by a shell might waste a lot of time. If you find that this is the case, you could move some functions to a separate script and use . to load that script in when you actually need to use those functions.

spmenu_run and packr both do this because it results in a pretty big speed improvement. spmenu_run is almost 1000 lines of Bash, and splitting the script like this cut the time it took for stuff to be printed in half.

In the case of packr, if you're installing a program you might not need to have any functions for removing programs. Why not load in the functions you need and no more? Well, there are some notable issues with this. It requires keeping track of more scripts, and if those scripts happen to be missing, your main script will not work. I think this is worth it though but only if you have really big scripts. For a 100 line shell script, this just isn't worth it because the slowdown isn't noticeable.

Conclusion

Shell scripting is basically magic, but you need to use it properly. The reason people aren't being taught to use the right tools for the job is because most articles regarding shell scripting are written for Bash specifically and not POSIX compliant scripts. This teaches new hackers to write Bash scripts when Bash is not required to get the job done.

In any case, hope this blog post was informative, have a good day!

2023-07-15

Warning: If you are not willing to listen to me talk about people who are obsessed over identity politics, stop reading this blog post now!

Today I'm going to say something I may come to regret in the future. Fuck it. This needs to be said. I may also lose more readers for this, or receive angry emails from people I dislike. That's not something that bothers me.

I'm sure if you follow my blog you're well aware of the petition against Richard Stallman that big technology companies signed. Big names like Mozilla, GNOME Foundation, LineageOS, OBS, Tor, X.org Foundation and even Creative Commons all signed this petition. Even some GNU/Linux channels like The Linux Experiment. This petition calls for the removal of the entire board of the FSF, and that of course includes Richard Stallman. Even the GNU project, which is Stallman's project.

Whether or not you believe Richard Stallman is a good person is not something I care about in any way. I don't care about that, and I don't care about him as a person to be honest. But I value Richard Stallman's work more than I will ever value this petition or frankly anyone who signed this petition, because despite Stallman's possible ethical flaws, he is responsible for a lot of good free software, including the free software movement itself. This petition wants to shame Stallman over things that don't really matter all that much in the software space. When you develop or use software, the political views of the developer doesn't matter, the end product does. And for the most part, the software he has worked on is pretty good.

This is just one example of the awful political activism which has slowly but surely taken over many free software projects, such as the Linux kernel and many other projects that people depend on. It's no longer about writing a good program but rather political activism and identity politics, which doesn't at all matter to the end user. The end user, the average normie just wants a program that doesn't suck and gets the job done. While saying politics should stay out of software entirely is a bit far fetched, considering free software (or even open source) is a movement, when you're actually writing a program it doesn't matter. It doesn't matter if a contributor believes in X, Y or Z or is a part of group X, Y or Z. If the code is good, it's good. If it isn't, then it isn't.

These people who are absolutely obsessed over politics are called SJWs, or "woke". In my experience, they may not admit it themselves, but usually they fall into this category. These people don't care about the software, they only care about making sure everyone involved in the project has (usually) liberal political views. If someone has different views, they will group together to shame that individual for their ideas, calling them a bunch of different names that I'm sure all of you have heard in the past even if the contribution the individual made is excellent and improves the project in a meaningful way. It's kind of difficult to avoid these people nowadays, and I am sure everyone who is reading this blog post has either come across one of these people, or are part of this group of people.

Either way, if you are one of these people, you are free to contribute to my software repositories. Same for the complete opposite part of the spectrum. I value these contributions equally, because they both result in a better product. The activism should stay out of software, that's the important part. Whatever you do outside of my repositories is not my concern in any way. Do however know that I will say what I want, whether you like it or not. And regardless of Stallman's views on politics or any other individual, I value and support the software and the software development, no matter who contributes to it.

2023-07-13

Alright, just a short blog post for today. I am NOT an open source enthusiast. Every time someone calls me a "open source" enthusiast, I want to shoot someone. I do not support the open source movement and I do not support open source software, or as a lot of people will say "FOSS".

Goal of open source software

The goal of open source is to provide the source code for ease of collaboration and for vulnerabilities to be discovered. Big companies can then take that project, which is almost always licenced under a cuck license, and release it in the form of nonfree software with additional spyware added on. The most notable example of this is the Google Chrome web browser, where Chromium is the "open source" variant of the software, only without the spyware and with the freedom to modify and distribute copies of the software.

Goal of free software

The goal of free/libre software on the other hand is freedom for all users of the software. These are:

1. The freedom to run the program
2. The freedom to study the program
3. The freedom to distribute the program to help others
4. The freedom to modify and distribute copies of the program

While free software is often copyleft, meaning you cannot fork the project and relicense it under a nonfree license, stripping away the freedom from the users of that fork, free software is not always copyleft. Therefore open source software is almost always compatible with free software. If you are using open source software you are most likely using free software.

Ethics

Open source software that meets the free software freedom criteria is just as ethical as free software. The main problem is you're sending the wrong message to people. But the software is still free as in freedom.

To be clear, I do believe nonfree software (software that doesn't meet the four essential freedoms) is unethical. But I do not dislike anyone for using nonfree software. It's kind of difficult to avoid using nonfree software in this day and age. Respect to those who are able to use 100% free software (going as far as using a libre kernel and free BIOS) though.

You are not unethical for using nonfree software. The unethical practice is actually licensing that software under a nonfree license and releasing the software to people.

Same thing?

A lot of people will say "what's the difference" or "who cares" when I mention I don't care for open source software. The reason it matters is because when you talk to people who may or may not care about freedom, you should be telling them that you care about freedom, not price.

FOSS stands for "Free and Open Source software" but I cannot stand this term, because it implies that the software is open source and free as in price, meaning you don't have to pay any money for it. Most people when they hear this term, both tech enthusiasts and normies think it means you get it for free. This is the problem. The message we should send is that the software is free as in freedom, not that it doesn't cost any money.

Conclusion

I am not for the open source movement. I do not support open source software for the sake of collaboration or for security vulnerabilities to be discovered. I support free software because free software respects users' four essential freedoms. Everything open source provides free software also provides. The main difference is the goal of the movement. I do not care for the open source movement and their motives. I care about the FSF's definition of free software and freedom for all users.

The reason "open source" is more popular now is because it's more corporate- friendly. Companies do not care about your freedom, but they certainly do care about unpaid work and security audits. Companies are against free software because they are against user freedom.

That's it for today. Have a good rest of your day!

2023-07-04

Alright, so as you guys know I have been very critical of Freedesktop in the past. Some of that I think is justified, some maybe less so. Today I'm going to talk about the complete opposite though. The XDG Base Directory specification, or what is in my opinion one of the best things Freedesktop have come up with.

What is XDG Base Directory?

XDG Base Directory is a specification by Freedesktop, but I would go as far as to call it a standard, because frankly if you're a developer who isn't following it, most end users hate you, myself included. I won't have you read the entire specification, so I will summarize the specification.

In the past, programs would just write configuration files, cache files, and other data wherever the hell the programmer decided that they should go. Perhaps this is practical to the programmer, but what ends up happening is users find that they have possibly hundreds of hidden files that they did not create.

The XDG Base Directory standard came around to solve this very real problem, by creating a few directories in the home directory, that programs can use for storing data, hence the name.

But what people tend to forget is that it doesn't necessarily have to be your home directory. You could put these directories anywhere your user has read and write permission, or hell, even /dev/null if you want to break stuff. This is why this specification rocks. But what are the directories and variables? There are many of them, but the most common are:

• $XDG_CONFIG_HOME
• $XDG_CACHE_HOME
• $XDG_DATA_HOME

All of them are unset by default, but when developing a program you should still read and use them. $XDG_CONFIG_HOME is where user configuration files should be read from and written to. On most systems, it is set to ~/.config by default. Does that sound familiar?

$XDG_CACHE_HOME is where cache files should be stored. On most systems, it is set to ~/.cache by default. $XDG_DATA_HOME is for program data, and is set to ~/.local/share by default on most systems. All of these will probably sound familiar to you if you have been using GNU/Linux or even BSD operating systems for a decent amount of time.

A common misconception

No, by placing config files into ~/.config or cache files in ~/.cache, you are NOT supporting the XDG Base Directory specification. I see this very often in shell scripts especially, and I've been guilty of it as well but to properly support the specification, you need to check the variable. If the variable is unset, you should (but technically don't have to) use the default path.

In shell script for instance, you would do something along the lines of mkdir -p ${XDG_CONFIG_HOME:-$HOME/.config}/my-software. In C you would use getenv("XDG_CONFIG_HOME");. But in any case, it isn't hard.

Why follow the specification?

If you're an end user, this is most likely already obvious to you. If you were to run simply ls on your home directory, you probably wouldn't think it's that bad. But that's because the ls command doesn't show dotfiles. Run ls -a ~/ instead. Look at the absolutely insane amount of dotfiles. In fact, you likely have more configuration files than normal files you actually care about. Your home directory has turned into a dumpster for programs to throw their config files and cache into.

By following the specification, you're allowing your users a lot more choice over their home directory. At the end of the day, it's their home directory, not the program's home directory.

If you do not follow this specification, you are actively causing your users pain and suffering from having a cluttered home directory. You go out of your way to treat your user's home folder like a dumpster. I am a minimalist, and I don't use that many programs. I have 28 hidden files and directories in my $HOME folder. Now imagine how many dotfiles your average GNOME or KDE user would have on his or her computer.

Please, for the love of god, if you're a developer, follow the XDG Base Directory specification. It really should be the XDG Base Directory specification, and the only people who are preventing this from happening are stubborn developers like you.

Following the specification is easy

Following the specification is incredibly easy, and even if you're new to software development (like me), you can easily follow the specification. All you have to do to support the specification is the following:

1. Check if the XDG variable is set. Depending on the type of file you're trying to store it will be different. For cache files, this is ${XDG_CACHE_HOME}, for config files this is ${XDG_CONFIG_HOME}, for general data this is ${XDG_DATA_HOME}.
2. If it isn't set, use the default for that variable. For ${XDG_CACHE_HOME}, it would be ~/.cache, for ${XDG_CONFIG_HOME} it is ~/.config and for ${XDG_DATA_HOME} it is ~/.local/share.
3. Create a directory inside whenever it makes sense to do so.

That's it. That's all you have to do. You're now one step closer to being a developer writing quality software, rather than a developer that makes your users consider throwing away their computers. It's not hard.

The only exception

The only exception where I think it is acceptable to not follow this standard, is when thousands of people heavily depend on a program, who require that the config file or cache path never change. There are a few such cases, Firefox being one notable example. I ultimately dislike having the .mozilla directory in my home directory, but the location changing could cause significant issues for a lot of people, who would have to adjust to it.

If your shiny new project doesn't support the XDG standard, especially if almost no people depend on it or its configuration file/cache file location, you have no excuse.

EOF

Some programs don't quite fully support the specification. The Arch wiki has an excellent article dedicated to software that can use the XDG standard, both programs that support it natively and programs that need a environment variable to be exported.

It's the XDG Base Directory standard. If you are a software developer, follow the standard. That's it for today, have a good day!

2023-07-03

Now, I would never go as far as to say Windows is better than GNU/Linux, but it still has the edge sometimes. Today I want to talk about one such case.

The problem

File pickers on GNU/Linux are the absolute worst. We've been able to write a new display protocol, Wayland but we somehow still can't have a file picker that doesn't lack basic features or even works for that matter.

This is not a minimalist nitpick. In fact what I'm really complaining about is the lack of basic features that people need. Okay, so let's say you have a Chromium tab open and a website you're on requires you to upload an image. Fine right? Now what if you don't know what the filename is?

On Windows, what you would probably do is click on a bunch of them, look at the image and see if it's the correct image in the preview pane. On GNU/Linux you cannot do this, because our file pickers are so crap and don't allow you to preview images. In fact, the only file picker I know of that supports this feature is Gimp, and that has a custom file picker that only Gimp uses. And it's clear why it has a custom file picker, it's because all the other file pickers are useless.

GTK file picker

This is what the GTK file picker looks like. GNOME and GTK has always had a minimalist design philosophy, not in terms of code or anything, but they've had simple UIs, just like Apple software. It's the Apple of the GNU/Linux space. There are multiple issues with this file picker, here are just a few:

• The aforementioned problem: Images don't have thumbnails, so you have no idea what you're uploading unless you know the filename.
• You cannot enter a path to a file. You can only see the parent directories.
• The pinned folders on the left are useless, and cannot be unpinned if those folders do not exist.
• You can't pin symlinks. This is massive problem for me at least, because I have ~/Screenshots, ~/Music, ~/Recordings and ~/Downloads symlinked to another drive.

Oh wait, you can enter a path to a file. You have to press / for it to display. But when you press / the path to the current directory will be removed. That is some awesome design right there.

QT file picker

Now, on the KDE side of things we have the QT picker. It looks a lot better. For one, it actually has a field for entering a path, which also shows the current directory. It has buttons for navigation and a "Filter" option. It also allows you to resize each pane, which is a basic feature that the GTK picker is lacking for some reason. A massive step in the right direction.

Only one small problem. Programs that use GTK, which are a lot of programs these days, including your web browser where you NEED a file picker that doesn't suck will still use the GTK file picker, which we've established sucks and is basically useless as a file picker.

This means you pretty much CAN'T escape the GTK file picker, because it's so tightly integrated with the whole GTK toolkit.

Windows was right

As you're surely aware of at this point, I use free software and I don't support nonfree software. However regardless, Windows does file pickers right. Everything positive I said about the QT file picker Windows has done for decades. It may be absolutely proprietary, but it is functional, something the GTK picker cannot say about itself.

You may notice some similarities between the Windows file picker and the QT file picker. Regardless, they're both functional and get the job done. You get a list of your files with image previews, both in the form of icons if you increase the icon size and in the form of the preview pane you can open up. The Windows file picker is actually even better though, because it actually displays EVERYTHING, rather than a few folders that you manually go out of your way to pin. It also works with shortcuts (basically symlinks) and handles drives too.

Conclusion

GTK and GNOME is about as useful as a painting. Cool to look at, but when you actually want to get stuff done, you're SOL. GNOME and GTK should take notes, quit designing a painting and instead think about what people ACTUALLY need out of their file pickers.

In the meantime, If you have a solution to this problem, please send me an email. In any case, that's it for me. Have a good day!

2023-07-02

Woah, is that an upgraded blog? Yes.

First I want to mention that blog posts are now being written in Markdown and converted to HTML and RSS feeds on the fly by a PHP script I hacked together. Formatting in the RSS feeds should be a lot nicer now, and I don't have to do anything beyond write the Markdown and put the file in the articles/ directory. But that's the reason you now once again have duplicate blog posts. I apologize for that.

Today I want to talk about something a little different. I've talked about the software I use in the past, but not really my system as a whole. If you've used spde in the past, you're already familiar with it because it sets up a system nearly identical to mine, except it doesn't have any of my files on it.

I apologize in advance for the ridiculous length of this blog post, I know it's long, but I wanted to go into detail about absolutely everything. Despite the long length of this blog post though, I still have not said everything I have to say. Insane, I know. I do not expect that you read all of this, but I want to truly document why I do what I do.

Regardless, I thought I'd write about my workflow, to hopefully give you some ideas on how you could potentially improve yours. Or at the very least, you could point out the flaws in my workflow so I can improve mine.

Goals

These are the goals for my workflow. If possible, everything I use should be designed around these goals. They are:

• Use the mouse as little as possible.
  • Some applications like the web browser just suck by design. In those cases I don't make any attempt to fix it.
• Use text as much as possible, because then I can use Vim which doesn't use the mouse.
• Get stuff done as quickly as possible. I need to be able to write code, text and documents quickly. The quicker the better.
• Some, but not too much eyecandy.
• Ideally written in C/C++ or shell script as well. But that's just because it's what I'm most familiar with, and I like being able to fix bugs in programs I use by myself. Of course, I would still use a good program even if it wasn't written in a language I know.

The computer

My operating system that I actually use is running on top of an Arch system in a QEMU virtual machine. Both the host system and the guest system have full disk encryption, as I believe this should be a standard. The reason I use a virtual machine for the actual work is because it allows me to only pass through some USB devices or some PCIe devices. It also allows me to quickly test different configurations or operating systems, and allows me to quickly back up and restore my system. I still have copies of my Gentoo system that I could restore right now. This is close to time travel as it gets. Awesome.

The system isn't too special, it's a box with a Intel Core i9 10900, 16 GB of DDR4 RAM, an AMD Radeon RX 570 and 580. The reason I have two graphics cards is so I can leave one to the host. If I need two virtual machines to both have decent graphics I can leave the integrated graphics to the host and pass through the two GPUs. These GPUs are quite old now, but I don't play any games on my computer or do any graphically demanding work, so they are fine.

Operating system

I use Arch Linux on both my laptop and desktop computer. I'm using a GNU/Linux distro because I value freedom and privacy, but also because it is impossible to achieve a good workflow on proprietary operating systems like Windows and macOS.

As for why I choose to use Arch, it gets updates often because it's a rolling release, PKGBUILDs (the format for building pacman packages) are very nice to work with for those who are familiar with shell scripting, and even if you're not into writing your own packages, there's the AUR (Arch User Repository) that users can push and pull from if the package you need isn't available in the main repositories.

While I could probably go with something like Parabola GNU/Linux-libre, my hardware does not fully support it, unfortunately.

Window manager

I use a standalone window manager (more specifically a dynamic tiling window manager) because allow you to move your windows without using the mouse. The reason I don't use a desktop environment is because a desktop environment comes with all the programs I'm going to mention set up for you. Most of these programs are not designed with the goals I have in mind though, so I would be getting a lot of programs I don't want to use. A window manager as the name implies only manages the windows, and it is up to me to find other programs that do other things I need to do.

Also, this applies to tiling window managers specifically, but instead of placing windows on top of each other, when using a tiling window manager you always have access to every window. This makes a massive difference if you have many windows open all the time. Instead of wasting several seconds snapping windows to the corners of the screen, why not have your window manager automatically split the screen for you?

The window manager I have chosen is as you guys probably know by now, dwm because it's fast and allows plenty of customization because everything is done in the C programming language. Basic customization is easy even with no C knowledge, and patches can be applied to add extra functionality. If you do happen to know C, you can implement a lot of features you want yourself and submit patches to suckless, and if you don't know C it's a great opportunity to learn more about C. This technically makes dwm the most feature rich window manager, AND the most minimal window manager. Very cool.

The best part is because you're forking the dwm window manager, you have the power to do anything you want. suckless can't randomly decide one day that they want to remove a feature that you depend on, or randomly break the project. If your dwm build breaks, it's your fault, because no one else is (presumably) working on it.

If you do not want to patch together a dwm build yourself, you can get mine here.

Terminal

Most of the programs that I use are terminal applications. Therefore, the terminal emulator is an essential part of my setup. For the same reasons I chose dwm as my window manager, I've chosen st as my terminal emulator of choice. I'd argue st (which stands for simple terminal) has the most features out of any terminal, and most potential for customization and new features. While st by default has many fewer features than xterm, my fork of st for instance has transparency, sixel graphics, clickable URLs, scrollback, keyboard select, ligatures, proper underlines, multi font support, wide glyph support, and more.

While there are terminals that offer these features separately, I have yet to find one that offer all of the above. While st doesn't have all of these out of the box, all of them can be combined into your st fork by using patches. The one notable feature st is missing that some terminal emulators like Alacritty offer is GPU accelerated buffers. But in most cases, this just isn't necessary or noticeable.

This was partially taken from Luke's build of st but if I press Ctrl+Shift+c I get a spmenu list of commands I've ran, and if I select one it will copy the output of that command. It will not run the command again, it will parse the terminal buffer and copy the output text to my clipboard.

Once again, if you do not want to patch together an st build yourself, you can get mine here.

File manager

For simple tasks like moving a single file to a different place, I will usually just use core utilities like cp to copy files around. But for more complicated tasks, I will use a program called vifm. Vifm is a terminal file manager, but I'm not using it because it's a terminal program. I'm using it because it's incredibly efficient. It has Vi-style keybinds, doesn't use the mouse, supports previewing PDFs, images, documents, music cover art and more using vifmrun and ueberzugpp. It's excellent, and I have yet to find a graphical file manager anywhere near as efficient.

If you're used to Vim, it will take almost no time to learn it. dd deletes a line in Vim, so naturally dd deletes a file or directory in Vifm. cw changes a word in Vim, so in Vifm is renames a file or directory. yy copies (yanks) a line in Vim, so in Vifm it copies a file or directory. It has two panes, one of which can be used as either a preview pane, or a second pane, allowing you to for example quickly copy between one directory and another. Speaking of Vim..

Text editor

The text editor I use should come as no surprise to anyone who has been following my blog for a while. If there is one skill I want every single person on the planet to learn it is the Vim text editor. Vim is the most important program in my workflow, and if I could only have one of the programs I mentioned in the blog post, it would definitely be Vim. Actually, more specifically Neovim. Neovim is just a fork of Vim which is more community oriented that also adds Lua scripting support and supports the XDG standard.

The reason you should use Vim is because it doesn't use the mouse for anything. While it is possible to use the mouse if you go out of your way to enable it, Vim is designed to be operated using exclusively the keyboard. Tasks that take a long time with a standard text editor, such as indenting thousands of lines, replacing complicated text becomes tasks that can be performed in seconds. And seemingly simple tasks like moving around in a file can be performed significantly faster with Vim. The mouse is no longer holding you back.

While it is true that it can have a steep learning curve, once you've actually learned it, you will regret not having learned it earlier. Vim changes the way you see and use programs, it changes the way you believe programs should be designed. It's incredible. The "steep learning curve" isn't as bad though, when you consider the fact that you can still use arrow keys when you begin and the mouse to move between lines. So if you're coming from a simple text editor you don't have to learn all of Vim's quirks all at once. You can (and will) gradually learn it. You start with arrow keys, then start using hjkl for movement and other basic keys like g and G

Vim is already an upgrade from your standard text editor out of the box, but if you want the text editor of your dreams, one that can match your IDE or at the very least edit text at the speed of light, you can bind keys in your configuration. The ones that changed my life are:

nnoremap <C-h> <C-w>h nnoremap <C-j> <C-w>j nnoremap <C-k> <C-w>k nnoremap <C-l> <C-w>l

nnoremap H :vertical resize +10<cr> nnoremap J :resize -10<cr> nnoremap K :resize +10<cr> nnoremap L :vertical resize -10<cr>

If you can't tell already, these allow you to split your Vim window into different sections using keybinds and resize those sections. If you want a more proper IDE, you can use Vim plugins, which add functionality to it. One of the most important plugins I use is Ctrlp which allows you to quickly open files recursively in your current working directory. I usually bind this to Ctrl+F but you can bind it to anything you want.

If you have a true color terminal (which you do if you use the aforementioned st) you have basically unlimited possibilities for customization. While images are a bit tricky, they can certainly be done.

Again, if you don't feel like doing all that configuration, you can get my configuration for Neovim here.

Music player

I like music, and I don't like music players that suck. Most of them suck, unfortunately. cmus is pretty nice though. It's fast and light, primarily because it's written in C and is a terminal application. While it's not entirely like Vim, it uses commands for navigation, supports playlists, metadata, and more. Pretty much all the basic media player functionality you could imagine. I've also heard of people using Ueberzug or similar to display the cover art inside cmus, but that isn't something I've tried yet.

You can control it without having the main program open using cmus-remote. Not only can you do basic media control with it such as next and previous track, pause, shuffle, repeat, etc. but you can also use it to query information about the playing track and cmus itself. This is useful in shell scripts, and I'm using this with my conky config to display the metadata and cover art for the playing track, and I'm also using it with my status bar. This is really nice.

I've tried and used other music players in the past, such as Musique, moc, musikcube, but all of them lack features I need. I still use musikcube occasionally, because it has a really nice feature. You can run musikcube on the computer that contains your music and other computers on your network can connect to it. You can even use a web server like Apache with it if you want.

Either way, there isn't that much to say about cmus, it's just excellent, and doesn't really require any configuration whatsoever. You just start it, add a music directory using :add ~/Music, update metadata using :update-cache and play your music.

Email

For email client, I use another terminal application called neomutt. It doesn't have Vi-style keybinds by default, but it can be customized significantly. In this case though, I haven't bothered and instead I simply use a script by Luke Smith called mutt wizard. This script is very nice because it sets up mutt with appropriate inboxes, downloads all the mail for you, sets up syncing and sets up neomutt with a sane config for people who like Vi-style keybinds.

Most email clients are terrible, and they usually take a very long time to open when all you want to do is see your email. With neomutt and mutt wizard however, because it downloads all the mail you don't need to be connected to the internet to see your emails, and all emails you've sent and received are stored locally on your computer, it opens instantly and you can instantly search through and delete your emails. It doesn't download any mail unless you request it to, or set up a cronjob to do it. I can't believe this is a core feature of most email clients. Mutt wizard rocks, and I have yet to find anything that comes even close in terms of user experience.

Of course, if you don't want to use Luke's script, you can definitely go and configure neomutt yourself. In fact I did this in the past. But for an ideal setup you need other programs along with it, and it's a lot to manage and set up. Luke's setup works perfectly for me, so all I do is install mutt wizard, log in and everything is ready to go and I can start syncing my emails.

RSS

I use RSS for media consumption, and this is for several reasons. RSS gives you what you want, and ONLY what you want. Nothing else. Most sites that people use like YouTube, Reddit and Twitter offer RSS feeds that you can use to get media. Odysee recently added RSS feeds as well, which is very nice. In fact, you might be reading this very blog post in an RSS reader.

Either way, I use a program called newsboat as my RSS reader. While it is a bit bloated in terms of dependencies, it gets the job done, and it is quite scriptable. It is also very easy to get into, you just add a few lines to ~/.config/newsboat/config and add your feeds to ~/.config/newsboat/urls and you're ready to go. Very nice.

I also use some scripts along with newsboat, that I can use to open, for example videos in mpv, or other links in my web browser. I also have a script to download videos using yt-dlp so I can watch them later locally without an internet connection.

My newsboat configuration can be found here if you don't want to deal with any of the configuration yourself. Keep in mind it doesn't come with any urls file though.

Image viewer

For viewing images, I use a program called nsxiv. It is a fork of the older sxiv image viewer. Not too much to say here, but nsxiv is a very scriptable image viewer. It can handle pretty much all types of images you can imagine, it loads them in and displays them quickly.

It is controlled primarily using keybinds. It has pretty much all the features you expect out of an image viewer, but also more specific features such as the -o flag, which will output the path to the images you mark. You can mark an image using the m key. This is a super useful feature.

Media player

For media playback, I use mpv. I've used VLC in the past, and while that's an okay player, it is a bit too bloated for me, and I don't really like the QT look it has. mpv is controlled primarily using keybinds, but can also be used with the mouse if all you need is basic features.

mpv has some pretty cool features though, such as YouTube playback using youtube-dl. The nice thing about this is that there are plugins like sponsorblock which as the name implies will skip sponsor segments in YouTube videos. I would like to see VLC do this.

There are other nice scripts for mpv like downloading lyrics for music and displaying it and I think you can even get a script which streams from a piracy site if that's something you are into. Either way, mpv is excellent and almost perfect, from the way they treat their users on Twitter, to the playback, to the possible customization.

Bluetooth, Wifi, Wallpapers, and more

One interesting thing about my setup is that I use scripts for a lot of things. There is far too much to note here, so I will dedicate this section to the different scripts I use.

For bluetooth, I've written a script that uses spmenu which interacts with the command line program bluetoothctl. While you can do this using a GUI program like blueman, this is incredibly fast. I just press Ctrl+Super+Shift+b and it will automatically scan for devices to connect to. Most people probably won't even have their bluetooth manager open when I'm already connected to the device.

Same goes for wifi, but here the script is a wrapper for iwctl, part of the iwd package.

For wallpapers, I'm once again using spmenu. I have a script that lists out my wallpapers and allows me to pick one. It also previews the images right there, no need for any external image viewers or anything. And when I choose a wallpaper, I have that work alongside my browser start page and window manager. When I select a wallpaper, the function in my config will use Pywal to get colors from that image and theme my terminal, status bar, web browser and web browser start page accordingly. And when my terminal emulator is themed, all TUI programs will be colored as well.

I have a lot more of these scripts, it never ends. I use similar spmenu scripts for clipboard management, password management, screen recording, taking screenshots and more. Scripts are incredibly useful.

Run launcher and bookmarking

For run launcher, I use spmenu_run. It handles both .desktop entries, traditional $PATH binaries, and even basic file management. Funnily enough, if you use spmenu_run on GNOME and plug in a device like a USB flash drive, it will actually ask if you want to open it in spmenu_run.

Bookmarking is also done using spmenu_run. If I type in @ I can get a list of bookmarks I've added, and I select one it will copy the link to the clipboard. (or run any other command I want it to)

I will add entries using @Cool link:echo https://cool.com | xclip -sel clipboard. I find this more useful than regular bookmarks because I can run any command I want, not just copy links to my clipboard. It's incredibly versatile and customizable. I should note that I will still occasionally use my browser's built in bookmarking though.

Web browser

I won't go too much into detail, but the web browser I use is Ungoogled Chromium. I've chosen this web browser because although the codebase is anything but minimal, it has a clean user interface, can be themed with the rest of my system, runs very quickly on both new and old systems, respects your privacy, and can be extended using extensions.

I don't use that many extensions. I use uBlock Origin because an ad blocker is essential if you want to use the modern web. There's just no way around it. I also use Vimium, which adds basic Vim motions to Chromium, and notably the f (follow) functionality. This was taken from Qutebrowser and allows you to navigate web pages exclusively using the keyboard. I usually use JShelter as well, which prevents some, but not all fingerprinting and other malicious things websites like to do. It's not perfect, something like GNU IceCat would be a LOT better for security, but this is good enough for me.

If you want to read more about why I like Ungoogled Chromium, check out my article titled Ungoogled Chromium - The best browser for most people.

PDFs

For reading PDFs, I use Zathura. The reason I use it as my PDF reader is because it opens instantly, has Vi-style keybinds, and supports everything a basic reader should, such as printing. Zathura can be themed, and so can the documents. I have it set to always use a dark theme, because a blinding white page isn't very nice.

Not too much to say here, if you know how to navigate in Vim, you know exactly how to navigate in Zathura. It's that simple.

Writing

I write almost everything in Markdown. The only exception is this website. But even then, the blog posts themselves are written in Markdown.

I like Markdown because it can be converted to any format you want using programs like Pandoc. All the software I write now uses Pandoc to generate man pages. It is really convenient.

EOF

Alright.. so, that's my system, I guess. As you can tell, it's heavily designed around Vim like programs and the command line. If you were wondering why I'm such a big fan of the UNIX philosophy, specifically the "handle text streams", this is why.

I believe I've perfected my setup now, which shows because I haven't been doing any major changes to my setup or workflow all year. I did briefly attempt to move over to Wayland a while ago, and while I did manage to rewrite my scripts to support both X11 and Wayland, I have decided to stick with X11 and my dwm fork.

Anyways, I think that's all I have to say. Have a good day!

2023-06-24

I talk a lot about freedom, privacy and free software on this blog, but today I want to talk about hosting your own services. But why should you host your own services? Isn't that really scary and difficult? Doesn't it require very powerful hardware? No, not really and I'm going to talk about some of the benefits here.

Alright so let's talk a bit about why you should host your own stuff and what you can host. There are many different services you can host. I'm hosting my website, some files, a Git server, wiki, email server and might host more in the future. But there are many cool things you can host, such as a Matrix homeserver, IRC network, SearX instance, PeerTube, NextCloud, it goes on and on. I won't be talking much about the specific services you can host today. But why should you host all of this stuff? Why not just use Gmail, or a public SearX instance, or GitHub, or any of these public services?

It's because as the sysadmin, you are very powerful and have a lot of power over your users and your services, and my site and services are no exception. You have power over everyone that uses your site and services. The ability to delete their accounts, look at what they're doing, all of these different things that you have no control over. When you host your own services though, the only one who is going to be able to see what you upload to your server is you (and your VPS provider if you're hosting using a VPS). Maybe other people can see it if they manage to compromise your server or you let your web server serve content that you don't want public. But in general, you're the only one who is going to be able to see that.

Let's take a public SearX instance for example. Let's say you visit searx.speedie.site and use it as your primary engine. Now, this search engine does not exist because I host my SearX instance locally but anyways, if you visit my SearX instance and use it to search for things, I have the power to log the search queries you search for, and I have the ability to see all the anime pornography you search for with great shame. Do you really trust me to not look at your search queries? No? So why should you trust any other SearX instance or hell, even Google for that matter. For this reason, you should take matters into your own hands and host your own services that you have control over. That way, you have the power to customize anything and everything about the service you're hosting, shut it down at any time to perform maintainence, set up logging, shred all logs and log absolutely nothing, etc.

But, doesn't hosting your own services require spending a lot of money? Doesn't it require a very powerful computer? No. If you want to host many, massive big files on a VPS or server that you rent, you may not have that much disk space. But even if that's the case you can host from home on a cheap old Dell Optiplex or maybe even a Raspberry Pi and just connect storage to it. I'm hosting a Git server using Gitea, and all the repositories Gitea handles combined only takes up approximately 870MB. And my public folder where I host downloads to all my software only takes up about 30MB. That really isn't much, and you can host that and much, much more on a cheap VPS. And the spmenu wiki I host takes up 31MB. So unless you want to host many, massive files I think making the argument that you don't have space is ridiculous. Any desktop computer from.. say 2008 or later is going to be able to handle hosting your site, and the terrible hard drive it has is going to be able to hold all of your files as well.

You can get a cheap VPS from Vultr for $3.50, and you can get a domain for usually very cheap as well. I went with Namecheap for my domain name, and they seem quite reliable and not very expensive. If you want to get a VPS from Vultr, feel free to use my referral link. There are other VPS companies though, and I still recommend hosting from home if you are able to, and your ISP reliably allows you to because it's likely still going to be a bit cheaper, but more importantly means you avoid the ability for your VPS provider to look at the contents of the virtual hard disk, and you are able to use more disk space. You have a lot more freedom that way. Still, a VPS is not a bad choice if you just want to host a few services and your personal site, but it's probably not the best option if you want to host NextCloud or a lot of big files or use it as a media server or anything like that. It also makes a lot more sense if you want to, for instance set up a VPN. Doing that on your own network doesn't make much sense unless you use the VPN away from home.

I won't get into hosting from home as that isn't something I'm familiar with (although I might try it at some point), and I also won't get into more complex setups or containers, just the basics. While I'm not a particularly big fan of Debian based GNU/Linux distributions, simply because of their old packages and the apt-get package manager, it's a fairly good choice if you want things to just work and serve your content all day every day. Despite not really liking Debian very much, it's what this website is hosted on, along with my other services I have.

When I'm using a VPS, I usually start by adding a new user and giving him a password. Then I usually install doas because it's smaller and has had fewer vulnerabilities than the more bloated sudo that people use. Then I will copy over my SSH keys to that user's .ssh directory. Finally, I always disable authentication using passwords for SSH, and more importantly I disable SSH as the root user. I do this because the root user is present on almost every machine, meaning if you want to gain access to someone's server by bruteforcing, a safe bet is to try to gain access using the root account. Then for extra security I will disable the actual root user, so the only way to gain superuser is to use doas Now you may have to open ports to be able to host anything on it. If you want to host websites you will have to open TCP port 80 for HTTP and 443 for HTTPS. On Vultr VPSes this is done using the ufw command, which is the firewall the VPS comes with. It should be noted though, that if you want to host an email server you will need to open port 25 used for SMTP, and should be done with the ufw command as well, but you also need to file a ticket on Vultr's website giving a valid reason for wanting the port to be opened. Usually they will accept your request, though.

Now that you've opened the ports you need, you can start hosting the services you wish to host. I would probably install Apache and php-fpm for PHP to get my website set up now. A VPS is going to function exactly like any GNU/Linux computer you're used to, although it will not have a graphical environment. Therefore you should expect to get familiar with Vim, it is your best friend. Anyways, you should host your own services, instead of using public services because it's more private, more secure, and you have much more control than with a public service that many people are going to use.

2023-06-22

It is no secret that I can't stand the absolute state of the modern GNU/Linux desktop. Even putting all of that aside though, there are some other issues I want to talk about. I've talked a lot about package management, audio and more, but the biggest problem is how we (the community) approach the normies. Many of these easy distributions come with a graphical package manager. Fair enough if you're new, right? These package managers often have a "featured" section, I know PopOS has one, and that's where the problem lies. PopOS and likely other distributions are actively recommending nonfree software through the "featured" section.

That is a huge problem because by recommending nonfree software you are telling normies that they SHOULD continue to use nonfree software, and they should not adapt to our ideas and start using free software alternatives. I get that some nonfree software just does not have good free software replacements, but you as the distro maintainer need to be able to put your foot down, and stop recommending Google Chrome or Microsoft Office or LastPass or other nonfree software when there are clear free software alternatives that usually accomplish the same task, and usually does a better job at it too.

The solution: Nonfree software should not be recommended by the GNU/Linux community. There is no harm in keeping it available, if not intentionally making it a little bit harder to install, because some users just are not able to move away from it for many different reasons. But we should not make it as easy to install nonfree software as it is to install free software. When you install GNU/Linux, you should be encouraged to move away from nonfree software for the most part in favor of free software that respects the user's freedom and privacy. By recommending nonfree software, you are encouraging the user not to care about privacy, and use GNU/Linux because "it works better than Windows" rather than "I care about my privacy and security".

If you have read ploum.net's excellent article titled We need more of Richard Stallman, not less you're no doubt aware of this already, but the free software foundation has slowly been replaced by the more corporate friendly open source movement which doesn't care about your freedom, only the collaboration aspect of free software. These same people want Stallman and the Free Software Foundation gone, because they actively dislike free software. The thing is we NEED Stallman's extremist views on software. We need to go all out on free software, not just use SOME free software but mostly nonfree software, because if we don't we still have terribly privacy and security. And when a "faster" or "better" version of the free software comes out, why shouldn't we just use that instead?

The best way to spread free software and avoid spreading nonfree software is to promote free software, and shame nonfree software for not respecting users' freedom and privacy. Normies usually get into free software by using GNU/Linux, so there's an excellent opportunity to promote free software rather than nonfree software.

Let me know what you think. Do you think it's justified to promote nonfree software? Do you think we should be even more strict, maybe not even allow nonfree software in the main repositories? I'm interested to hear about it. Have a good day.

2023-06-17

Today I want to talk about my experience using Wayland compositors and software, as well as developing Wayland clients for Wayland using the wayland-client library. I've talked about the protocol itself in the past, usually in a negative light because that's how I see it for the most part, but after using Wayland for a bit I have some more things to say about it, and I want to talk about those today.

First of all, Wayland is not a display server, just like X11 isn't a display server. X11 and Wayland are both display protocols, which then have to be implemented. X11 has a standard implementation, called Xorg. While this isn't the only implementation of the X11 protocol, it is by far the most used one. This is called a display server. Wayland on the other hand does not have a single implementation more popular than others, because each compositor has to implement the Wayland protocol themselves. This can lead to issues if a compositor doesn't implement a core part of the protocol. This means the compositor is also the display server. But because implementing an entire display server and following the Wayland spec is complicated and time consuming, libraries such as wlroots and swl have been created, which implement a lot of the Wayland functionality for you. This is really as far as standards go with Wayland, because every Wlroots based compositor is compatible with each other. The problem now is everyone is going to base on Wlroots, and for good reason because no one really wants to write all that code.

Except not everyone wants to use Wlroots. For example GNOME and KDE both have their own Wayland implementation (because of course they do), and this leads to problems such as software only being written to work with Wlroots based compositors or GNOME/KDE. From a developer's perspective, you can't just leave out GNOME because GNOME is incredibly popular and used by a very significant amount of GNU/Linux users, but at the same time if you leave out Wlroots based compositors a lot of power users aren't going to be able to use the software on their favorite compositor, so no power users are going to be using the software. So the developer has to support BOTH GNOME and Wlroots, and most likely also test on both Wlroots and GNOME, unless the program has a significant enough userbase. GNOME has a history of doing their own thing instead of following a standard, and making decisions that only benefit GNOME and no one else, which is likely why they implemented their own version of the Wayland protocol. Whether that's true or not doesn't matter, because right now there's no standard implementation of the Wayland protocol, leading to more work for the developer.

As you probably know, about two weeks ago I finished porting my program spmenu over to Wayland. While I was working on the port however, I almost immediately noticed how lacking Wayland really is in terms of features. They claim this is for "security", but I don't buy this argument for several reasons. spmenu has a feature to position itself at a specific X or Y position on the screen, but in the name of security wayland-client (the library used to create Wayland clients) does not allow you to do this. I ended up disabling this feature in the final product, which really should not have to be done. I get that this can't be done with a standard window, but this is a layer window, meaning it's supposed to be layered above all other windows, so it makes sense to allow it to be placed anywhere.

The reason I don't think security is a valid excuse here, is because with the wlr-layer-shell protocol you can grab the keyboard and (almost) all input, and grab the focus all to yourself. That's a much higher security risk than allowing the window to position itself anywhere. Instead of allowing a specific position, we instead have anchors, allowing us to anchor the window to a predefined part of the screen, such as top, bottom and center. Also, if you have programs doing malicious things by positioning itself, you have a much bigger problem. Wayland does do some things in the name of security that I think are somewhat justified, such as not allowing a client to move another client, or read keystrokes when the program isn't actually used. That's very useful for keylogging and other nasty things. But at the same time, if you have malware on your computer, then you have bigger problems than that, and there are legitimate uses for logging keys or moving other clients, which now aren't going to be possible anymore in the name of security.

Alright, so we've established that Wayland has fewer features than X11, how could things get any worse? GNOME has the answer to that. Because there's no standard implementation, you can just choose not to implement certain features. wlr-layer-shell is a unstable protocol, but despite this it's the only way to create a run launcher that functions like.. a run launcher, at least on the Wlroots implementation of Wayland. GNOME however doesn't implement wlr-layer-shell so any programs that use wlr-layer-shell will not function under GNOME, and spmenu is no exception to this. It doesn't make it any better that GNOME has a very high authority over the direction Wayland is going in, and really the direction GNU/Linux as a whole is going in.

Okay, but what's Wayland really like to use for the average user? Mixed, let's just say that. If you're using a desktop environment, chances are you don't even notice any difference between it and the same desktop environment on X11, at least none that isn't positive. If you're using a window manager on the other hand, you're going to notice things right away. Many programs that you may be using just will not function anymore, particularly the programs that capture the display. Wayland shills will claim that Wayland has support for all your X11 programs, but while that's not entirely false, anything that captures the screen itself is going to be totally broken on Wayland.

One thing I noticed fairly quickly is that screenshotting doesn't work. I'm using a tool called maim for this, and maim is X11 specific. Great, use XWayland right? XWayland doesn't work for this purpose, and as a result the capture is just black. What about ffmpeg and x11grab? Nope, doesn't work and all you get is a black screen. Turns out on Wayland you need Pipewire (or another tool) to capture the screen, and ffmpeg doesn't support this, so if you had plans of using Wayland and at the same time using ffmpeg to capture your screen, you're out of luck. While replacements for the X11 specific software does exist, much of it is very buggy, broken, not in repositories or just not the same thing. Recording using ffmpeg can be replaced using a command line utility called wf-recorder, but screenshots are little more complex.

On Arch, you need to manually compile a program called wayshot (a program that functions as a maim replacement) because the version you can get from the AUR is out of date and doesn't support using slurp (a slop replacement), meaning you can't select. After that though, everything works pretty much as expected. But what about copying the image to the clipboard? Well, on X11 we can just pipe the image into xclip -sel clipboard -t image/png, but as you might expect this isn't built to use Wayland natively. It does work, at least with XWayland compatible compositors but to do it natively you'll want a replacement called wl-clipboard and the wl-copy command. The wl-copy command works pretty much in the same way, pipe the image or text into it. Unlike with xclip though, you don't need to specify a type, and wl-copy only supports one clipboard so you don't need to specify a selection either.

Normal X11 programs though that run in a normal window or floating window usually work fine, and I was able to carry on using my X11 terminal emulator which is st just fine, with no noticeable loss in speed. No configuration is required for these to function with most compositors, although some don't support XWayland such as Qtile, so with those you may not be able to use your X11 specific programs.

What about Wayland compositors? Most of them are terrible in my experience. Maybe there's some secret awesome compositor, but every single one I have used so far has had some major flaw that makes it unusable. I started off my Wayland journey on Hyprland because I hear that's what most people use. The default keybinds are absolutely awful, and a good example of that is Super+q which doesn't quit Hyprland or close a window, but rather spawns Kitty, which isn't even a Wayland specific terminal emulator. Certainly a weird default. Even after some configuration though, Hyprland has several issues. For one, if you set a wallpaper using swaybg or hyprpaper the computer runs much slower, and Chromium seems to freeze at random. This happens with all my computers, with both Intel graphics and AMD graphics. I ended up determining that it was a problem with Hyprland because with dwl,sway and river everything worked perfectly with a wallpaper set. Most of these compositors also do not have a built in bar, sway is the only one I found that has one, not even dwl which is supposed to be a dwm clone has a built in bar, despite using way more lines of code than the original dwm.

Wayland has several issues as well that make the entire product completely unusable. For one, I have never been able to get it to work on my NVIDIA GPU (GTX 1060 6GB) system. Not with the free software driver and not with the nonfree nvidia driver. It's possible it works with GNOME or KDE, but I have no interest in running any of those, and I don't care for desktop environments. While it isn't fair to blame Wayland or Wlroots for this, in practice I'm unable to use Wayland on my NVIDIA system, and as such I decided it was worth mentioning.

By the way, I should also mention that I have implemented Wayland screen capturing into dfmpeg-spmenu and screenshot-spmenu if you want to use spmenu for screenshots or screen recording. This is also X11 compatible, so you don't need to switch script whenever you switch back to X11.

Anyways, I'm done with Wayland as of now. I will keep a session around to try out my own software in and will continue to support Wayland in spmenu, but I will not use Wayland anymore, and I am very happy to go back to dwm and X11. I may eventually make a second part to this blog post where I talk about actual code and programming in C for Wayland, but I'm going to end this blog post here. If you had an interesting experience with Wayland or thoughts on Wayland, feel free to share it with me. Thank you for reading, have a good day!

2023-06-08

I often hear people following my blog or just know me for one reason or another, and usually it goes something like this:

Hello speedie I enjoy reading your blog.

Thanks!

I’m using X nonfree software or Y desktop environment, sorry about that.

This is the problem. I see far too many people apologize for their choices in technology, but I want to make one thing clear. I am not here to judge your technology choices. If you want to read my blog on Windows and/or Mac, use nonfree programs, hate my software or ideas, or do something else I’m not personally a fan of then you are 100% free to do so. You don’t need to justify your use of software or hardware, that is a personal decision you are making. I am not going to make that for you, and while I may not agree with your decision, it is not mine to make.

I may suggest replacements for the software you’re using if I believe it’ s something you would benefit from (such as learning Vim or getting into tiling window managers), but I’m never going to force you to use/do something, or shame you for using the nonfree software or software I simply don’t like. I am also never going to force you to believe the same thing as me, that’s idiotic, and the definition of an echo chamber, something I’m very against. I don’t want 15 speedie clones, you should have your own ideas, and I should have my own ideas. If we agree then we do, if we don’t, then we don’t. I make decisions you may find stupid, you make decisions I may find stupid, and if we don’t debate each other’s ideas, we lose the ability to think for ourselves.

That’s not to say it’s harmful to criticize the choices others make, but you need to be willing to see both sides of the coin, and like it or not you need to accept the choice the other person is making, whether you approve of it or not. That’s just a short blog post for today, as I see this far too often, and I think it’s important to say this. I’m probably going to talk about Wayland development, Wayland libraries, Wayland protocols and Wayland implementations next time now that I’ve truly given Wayland development a fighting chance to win me over. That’s it for me, have a good day!

2023-06-03

Wow, look at that. Even more junk to fill my catalog and make it look like I've done more writing than I actually have. Oh well. I'll get straight to the point. At approximately 02:32 I quickly made the decision to move from cgit to Gitea for hosting my Git repositories and projects. For this reason, links to the old Git repositories need to be changed. This mainly applies to those of you that are using speedie-aur, or speedie-overlay. I'm assuming that's quite few of you, but just in case I'm putting this out there.

If you're using speedie-aur, you'll need to edit /etc/pacman.conf and change the Server to Server = https://git.speedie.site/speedie/speedie-aur/raw/branch/master/$arch. If you're using speedie-overlay you'll want to remove the overlay and add it again. See the repository for more information. The Arch wiki article has been updated to reflect these changes as well, and so has the overlay.xml.

I have also moved over a lot of GitHub repositories to my Gitea instance, such as my Gentoo kernel for my ThinkPad and desktop, multiple OpenCore configurations, and more, but all Codeberg and GitHub repositories are still accessible. It should be noted though, that I plan on moving all website development to the Gitea instance rather than Codeberg.

What you may be screaming right now is WHY? I'll tell you why. Cgit is an excellent Git viewer, but that's all it is. A git viewer. It doesn't handle your repositories, no issue tracking, no pull requests, no users, nothing. This is fine when you're the only one working on a project, as you're going to do most work locally on your computer anyway, and then push using Git from the command line. The problem is when you want to have any kind of collaboration, which is something I realized today (and yesterday). As some of my projects are becoming increasingly complex, I need a way for people to submit bug reports and fix issues. Emailing isn't convenient for the user, and it isn't convenient for me either. Now that I'm using Gitea, any user may create an account and simply create an issue or pull request. There's not any more to it, just simple. If you're familiar with GitHub or even one of the public Gitea instances like Codeberg, this is likely nothing new to you.

Now, while I'm writing this blog post I also want to talk about some future changes. I want to slowly move from w2wiki to simply a static website that people can edit through issues and pull requests. In my opinion this is a lot better, not only for security but convenience and flexibility. W2wiki is pretty good, but it is definitely not designed with security in mind, and it isn't hard for anyone to simply remove the entire thing with minimal effort, as we saw with the old speedie.site wiki a while ago.

While it is a static site for the most part, I may still be using PHP if necessary, especially for maintainence. No JavaScript however, although it should be noted that the Gitea instance does use JavaScript. There is just no way around it as far as I know, so it will have to do. All the JavaScript is free as in freedom, which is the important part. I have no plans to put JavaScript anywhere else on my site though, as long as it's feasible. Anyways that's just a small site update. Have been busy with my spmenu Wayland port and other things like that, but now that it's complete I plan on posting more blog posts, as I have a lot of things I want to cover eventually. That's it for me, have a good day!

2023-05-23

It is no secret that I strongly believe in copyleft licenses like the GNU General Public License (often shortened to GNU GPL or GPL) and the Mozilla Public License (MPL). Copyleft licenses as the name implies are the opposite of copyright licenses. With copyleft licenses, the user has the freedom to modify, study and distribute the software and source code. But unfortunately in recent years copyleft licenses have fallen out of favor thanks to tech companies like Microsoft heavily pushing too permissive licenses to developers. These licenses (which I will call 'cuck licenses' from now on) rob developers of their work. Now, it should probably be noted that I am not a lawyer, nor am I more experienced in any legal system that most people. I'm just here to talk about the best software license today.

With cuck licenses, the developer writes the code and puts it out on the internet like usual. The difference is there is nothing that prevents anyone from forking it and changing the license. You might ask why this matters. It matters because big tech companies like Microsoft, Google, Apple, Nvidia, Meta, and many more will take these free software projects, change the license to a nonfree license and no longer distribute the source code for the software. Most of these cuck licenses only require that the license notice is kept in every piece of code. However you're only distributing a binary though, the license isn't noticeable anyway.

I'm sure you can tell by now, but tech companies LOVE cuck licensers, because cuck licensers do the work for them and for free. The companies then just steal that source code and make their own proprietary variant. No attribution, no money, nothing. Some developer writes the code for free and a big tech company will steal it and make a nonfree spyware variant of it. When tech companies write software, they will usually license their own software too under the BSD licenses or more commonly, the MIT license. The MIT license is probably one of the worst licenses out there in terms of stripping the developer of his/her freedom. The user still has the freedom to use, study and modify the software. That is, until a tech company forks the project and changes the license to a nonfree one.

An example of a bad case of cuck licensing is MINIX, a portable UNIX like operating system. Because this project is cuck licensed, Intel decided to fork the project, apply some spyware modifications to it and relicense it under a proprietary license so no one knows what the code really does. Now all Intel users have this backdoor in their computer in what's called the Intel Management Engine (ME). Or take Google Chrome. Google forked the Webkit engine and made their own web engine called Blink. The Chromium browser which implements this engine is free software, but Google Chrome (which is very similar) is a nonfree program which does god knows what.

But you, the developer can fight back against this by licensing your software under a copyleft license. Copyleft licenses usually require that the forked software is licensed under the same license. So if you license your software under the GNU General Public License version 3, all copies of the software including forks are going to be licensed under that same license. This is great for developers because their code is always used for free software and not nonfree software. It's also great for users, as it means there will be less nonfree software to use and more free software to use instead.

I should note that I switched all software I've written from scratch to the GNU General Public License version 3 about a year ago or so from the MIT license and it gives me more freedom, and it also means everyone who uses my software or forks of my software is guaranteed freedom. It's a win for everybody, and it means together we're working towards a more free computing experience for everyone. It has its flaws though, which is why some may consider the LGPL or Lesser General Public License. This license unlike the regular GPL allows embedding the software in proprietary programs. This may actually be preferable in some cases, but in general you should stick to the regular GPL. I know there are more licenses than the GPL and MPL, but I'm not going to get into license specifics too much here. I'm mainly talking about the GPL because that's what I license all my software under.

Conclusion then. Cuck licensers write the software for big tech companies for free. They get nothing in return and users get a piece of crap proprietary program when the big company forks the originally free software program. With copyleft licenses on the other hand, the user is guaranteed the freedom to modify, study and distribute the source code or program. Switch to the GNU GPL today or any of the other GPL compatible copyleft licenses and truly become a free software computer programmer.

2023-05-01

Today I want to talk about my favorite web browser which I have been using for several months now and that is Chromium, specifically Ungoogled Chromium. Ungoogled Chromium is the best browser because it's fast, it respects your privacy, but also doesn't provide any extra bloat or anything, it's just a fast, privacy respecting web browser that does everything you need and nothing more. In a lot of ways it's the best web browser for minimalists, but also for normies because it requires no learning coming from Chrome or whatever.

If you are on Arch, you can get it from the AUR, and I also have a package available in my arch repository, so if you're using speedie-aur you can just pacman -S ungoogled-chromium. When you start it for the first time, if you're coming from regular Chromium or maybe the horrible spyware that is Google Chrome, you're going to notice that it looks a bit more minimal. That's because most of the Google junk has been removed, so what you have is what you actually need out of a web browser. By default, no search engine is active/enabled though, but if you want one you can go to the settings like in regular Chromium and simply add one.

The second thing you're likely going to notice pretty quickly about Ungoogled Chromium is by default it actually doesn't save cookies, so after you close your web browser you have to log in again. Now, I consider this a feature rather than a bug for security reasons, and while this isn't a security oriented web browser, most of its users are privacy enthusiasts, so I consider this a nice default. If you don't like this though, you can just change it in the settings. If you're setting up this browser for a normie, you may want to enable saving cookies, because in the society we live in normies would be very confused when their web browser doesn't keep them logged in.

Ungoogled Chromium is not hardened by default though. For good security I would install JShelter, uBlock Origin, LocalCDN, and a few other privacy oriented extensions. I would probably also install Vimium, which allows you to follow links using f and use general Vim-like keys to navigate the web, and of course a dark theme of some kind.

The reason I find this browser is better than others is because it's based on the Chromium web engine making it extremely fast, but it also respects your privacy by removing all the Google junk. Chromium is a good browser outside of all that Google spyware, because Google knows what a good browser is. A good browser is fast, minimal and allows you to view websites and nothing more. Google has known this since the beginning, and that's why this is such a good web browser. Other web browsers often fail at this.

I should note that due to all the Google junk being removed, you can't actually install extensions through the Chrome Web Store. However there's an extension you can install manually, which will allow extensions to be installed from the web store anyway, but you should RTFM for that. The extension is available here, and was designed with ungoogled-chromium in mind. While you don't need it, it makes the process of "manually" installing extensions a whole lot easier. It even does updating for you, although it requires some user input.

As if this web browser wasn't already excellent, The --app argument makes it even more useful. In fact it makes all Electron applications basically obsolete. If you do.. for example chromium --app="https://speedie.site" you'll pretty much have an app for my website as the name implies just like Electron would do, except it's using your existing web browser. This makes it slightly more appealing. It even changes the icon to the favicon for the site. I'm using this feature for Element (the Matrix client I use) and Discord. I combine this with my run launcher to have super awesome web apps.

Overall, I highly recommend this browser. While it's not the most secure (you'd probably want GNU IceCat or LibreWolf for that), it's super fast, it's free as in freedom and it's minimal and clean. It provides sane defaults such as not storing cookies by default. It's a good web browser for both normies and people who know how to use technology, because I think both groups of people find its features appealing. If not, I guess the normie can continue using Chromium and you can use Ungoogled Chromium and get privacy from it. Thank you for reading, I highly recommend Ungoogled Chromium, and have a good day!

2023-04-28

Today I want to talk about Wayland, and why I don't use it. In case you're a normie and don't know what Wayland is, Wayland is this new display protocol created by the people over at Freedesktop. They want it to be better than the display protocol most GNU/Linux users are already using called X11. While I'm not against the idea of a new display protocol, in my opinion Wayland is a failure, and it fails at doing everything X11 did right, and that's what I want to talk about here. Note that most of this will be from a developer's perspective; if you're using GNOME, KDE or maybe even one of the many wlroots based compositors, your experience on Wayland is probably going to be pretty good.

Terminology

First, let's talk terminology. On X11 we have something called a 'Window manager', and as the name implies it manages your window. The window manager is the root window, meaning it's the first window. Other than that, it's just like any other window you may have. This is quite powerful, because it means in theory anything can be a window manager. You can try this for yourself on Xorg and xinit by running startx /usr/bin/firefox. What you should have is an X11 session with only firefox open and nothing else. This is why we have window managers, they allow us to spawn more windows and place those windows wherever we want. Even desktop environment users have a window manager, because your desktop environment comes bundled with one.

On Wayland and X11, we have something called a compositor. Let's ignore Wayland's definition completely for now. On a basic level, the compositor provides fancy effects such as transparency, rounded corners with anti-aliasing, shadows, animations and other things you may or may not want. One of the most popular compositors today is called Picom, and most standalone window manager users use it, if they use a compositor at all. This works by creating buffer where these effects are added, and then displaying the buffer to the user. This is why older machines may feel slow when a compositor is running, it's just not displaying that buffer quickly enough.

In X11, a client is pretty much the same thing as a window. I am going to be using the term 'window' throughout this blog post, but client is what I usually use when referring to an X11 window.

'Xorg' is an implementation of the X11 protocol, and it's the implementation most users are using. There are other ones like XFree86, but most users use Xorg.

The compositor problem

This is where Wayland's problem for me comes in. On X11 these two components are separate, so I can pick and choose each component and just combine what I like. With Wayland, they have decided to combine the compositor and window manager into one program, which to make it even more confusing is also called a compositor. Now, why is this so bad?

• Less modular

By combining the compositor and window manager, you're slowly making the display stack less and less modular. The days of choosing your compositor and choosing your window manager are now gone. It's all one big program, meaning even if you avoid desktop environments you're still going to have one big program that does everything. This is just not the way forward if you ask me. I believe the main reason for this is "making the desktop easier for new users", but at this point the GNU/Linux community should give up on new users who aren't willing to learn our technology.

• Window managers are so complex

It is incredibly easy to make an X11 window manager, because again it's a window like any other. You really just need to create a window, read atoms and finally move/resize windows around. On Wayland you now also need to implement a compositor, which adds a lot of complexity and room for failure. Even one of the more minimal Wayland compsitors dwl, a dwm rewrite for Wayland has many more lines of code than the original dwm, because now you also need to do the compositing yourself. Not to mention, if you're using a minimal compositor like dwl, you can't have fancy effects and a minimal window manager, that's just not possible anymore, at least as of now.

This added complexity led to libraries like wlroots being created, and its slogan really says it all; "about 60,000 lines of code you were going to write anyway". However even with wlroots you still need to implement compositing, there's no way to have a separate compositor with your window manager.

• No, a Wayland compositor is not a window like any other.

As I said earlier, a window manager on X11 is a window like any other. The only difference is it's the first window spawned (root window), and it is responsible for creating, resizing and displaying all other windows, although this is technically not a requirement. This is good because you can for example startx /usr/bin/firefox and have an X11 session that runs Firefox. Nothing else, just Firefox. This goes for any graphical program such as your terminal emulator, text editor, Emacs, etc. On Wayland, this is not possible, because windows do not implement compositing whatsoever. They are only responsible for creating themselves.

• How about no compositor

I think this is worth mentioning as well. A lot of X11 users simply don't use a compositor at all. They deem it unnecessary, and it makes sense. If you don't need transparency, fancy effects, Vsync and other nice features like that, why should you waste your system resources on a compositor? Good luck omitting the compositor when you're using Wayland. You can't.

Those are the problems that come as a result of combining the compositor and window manager. While I'm sure there could be benefits to combining the compositor and window manager as well, I just cannot think of a single reason.

What change do I want to see?

I want a more minimal display protocol. Wayland is more minimal so I think it passes here. What I also want is a more modular display protocol, and this is where Wayland seems to fail. X11 did this right, but I want it even more modular than X11. Everything should be separate, as long as it doesn't harm the user experience. Not to mention, more modular software is usually more secure, because each module is much smaller and easier to maintain.

I also want a library which allows creating BOTH X11 and Wayland clients without writing any extra code for it. This would be ideal, although I'm sure there are potential challenges from doing it this way. You might say, "Just use GTK or QT" but they also require writing extra code for Wayland or X11 support. This leads to developers not supporting one or the other.

For example, I want to add Wayland support into spmenu. I'd be happy to do so, but the problem is it would require rewriting the code for creating the window, handling events, keybinds, clicks, drawing, mapping, and more. It's just not something I want to deal with, which is why I've chosen to not write any of my software to use Wayland native libraries. There is XWayland, but to my knowledge there's no such thing in reverse.

Conclusion

I want to mention that I'm very much open-minded towards a new display protocol. I'm all for a new, more minimal, more stable display protocol. It's just that Wayland makes it a pain to write compositors, and in many ways it's a downgrade from X11, which is really old I might add. That's not to say Wayland has no improvements and X11 is perfect. The most popular X11 implementation, Xorg is extremely bloated and has a lot of legacy code that really doesn't matter today and the protocol itself is probably not much better.

It also has absolutely horrible security. But all things considered, I think X11 just has much better ideas on what the desktop should be than Wayland does. If Wayland improves the things I don't particularly like, I may end up switching to it. But as of now, X11 works fine for me and the benefits of Wayland just aren't worth it, so I am going to be sticking with X11. If you know of any solution to this problem, I'd love to hear it, and I'd love to give Wayland a proper chance.

Thank you for reading, have a good day!

2023-04-19

Now that most of my issues regarding this site are resolved, I want to start writing about something. I have a lot of topics I want to talk about, however for many of these topics there's just not much content to them, so I apologize for the length of some of these.

Anyways what better topic to start with than this one. My blog isn't perfect, I post a lot of garbage here quite often, but what pisses me off is when people will write blog posts, have an RSS feed and then ruin it with one thing. They will put about 1/10 of the blog post in the description tag, and then they will have the blog post in full on their website.

This is extremely annoying, because it means I have to open up my bloated web browser just to view your blog post which could normally be read using my RSS reader, which is designed for reading blog posts. What if I want to read your blog post on the command line? Or what if I want to read your blog post when I don't have internet?

Good RSS readers like Newsboat and sfeed store the full feed locally, meaning you can actually read the articles even when you don't have any internet connection. But when you force me to go to your website, I can't just save it when I do have internet and read the blog post whenever I want to read it. Now, I know why you would do this. If you have a site, chances are you want people to visit it. RSS is convenient, very convenient and I'm going to admit I don't actually visit the sites for blogs I follow very often, usually I read the feeds every day and then very occasionally visit the websites. But I still think this is annoying.

So, if you're going to have a blog and you plan on using RSS, please provide the full blog post in the description tag. I know this can cause issues with paragraphs, but you can steal my feed as a base if you want. Thanks for reading, and have a good day.

2023-04-14

I will keep this one short so you can actually read through it. Yesterday (13/04/2023) I purchased a domain, because as we all know I do not trust Freenom to keep my site up. This domain is a lot more reliable, however it does mean you will have to swap out '.gq' for '.site'. I have redirected some parts of my site. I have redirected the main speedie.gq domain, and I have also redirected rss.xml so that RSS readers won't complain. You should still change the URL, however if you exclusively consume my website through RSS you will get the message anyway because of this. Finally I redirected the wiki.

Switching over is not hard. The page is identical, and although SSL was not functioning earlier today, I have resolved the issue. So to switch over, just replace 'speedie.gq' with 'speedie.site'. This is especially important if you use Arch and my repository. If you do, you must edit /etc/pacman.conf and replace the URL. There may be a few sharp edges as of now, as I simply ran a few sed commands on the old site without looking through it properly, if there are issues please email me so it gets fixed. I should also add I moved from Nginx to Apache a few days ago.

Anyway, that was just a short blog post about something relatively important. I will probably keep the speedie.gq domain updated as well, but I cannot guarantee it will work properly. If you have any questions, feel free to email me, or simply join the Matrix space. Either way, that's it, have a good rest of your day!

2023-04-01

As you guys may know if you have been a speedie.site reader for a while, I was a Gentoo user, and recently I switched to using Arch full time. However, I am yet again switching operating system because I just found out Windows is the best operating system ever made.

Linux sucks, but Windows is awesome!

Now, most of you probably use some open source Linux distribution on your computer. But Linux is open source, and that's bad. That means Russian hackers can steal your porn collection because of course they can see all the source code and backdoor it. When you're using Microsoft Windows on the other hand, the only one who can access your data is Microsoft, who will send that data to the NSA. This also makes sure your data is safe, and that you're following the law like any good citizen. When I'm using Windows I feel safe and no malware has access to my data. The same cannot be said for Linux or any other open source operating system

These Linux users who never go outside or shower will say that this is malicious, or that it is spyware, or any other nonsense but the fact of the matter is the government already knows everything about you anyway. You should not care about privacy if you have nothing to hide, so of course Linux users have a lot to hide. The government would never do anything bad anyway, they only want the best for you.

Tiling window managers suck

Why would you use a tiling window manager? Only hackers use those. Tiling window managers are also really hard to use, I mean think about all the keybinds you need to remember to get good at using one.

What about speedwm? I'm just kidding, I've been secretly using GNOME for years, and I was never using speedwm in the first place. Hating Wayland? Actually, I've been using a Wayland session on GNOME for a long time now. As we all know, X11 is old and slow, and it's not written in Rust so that makes it instantly bad. spmenu? It's just rofi with a theme.

C programming language? Hell no, it's so hard to learn and it's so old. Real programmers use JavaScript for the frontend and Rust for the backend. Recently though, I've started using C# which is superior to both of these in every way. We all love Micorsoft.

Vim is only used by furries, neckbeards and weirdos

Vim is a meme Linux users force onto new users. In reality, Vim is hard to use and it's so slow, I can't even figure out how to exit it. If I can't even exit it, how can I use it to write code? Why wouldn't you just use a mouse anyway? It's not 1983 anymore, we have modern, proper computers for real people now. The only people who still use Vim are neckbeards who want to look cool on the internet but in reality don't have a life.

Visual Studio Code on the other hand is the greatest code editor ever and it's what I've been using for months now, while people were under the impression that I'm an avid Vim user. It's "open source" so that the Linux neckbeards will use it, but uses a mouse, because it's 2023 and if you're not using a mouse for everything except typing, you're lost in the past. It also supports JavaScript plugins and has a lot of Microsoft telemetry, so they know you're doing a good job writing programs for the future.

Installing programs

Linux users claim that using their terrible package managers is better than downloading executables from the internet directly. This is just not true, because the package managers can be hijacked remotely by Russia to spread propaganda to all of the users. This doesn't happen when you download random executables from the internet, because Microsoft Defender is guarding your computer, and has a 100% success rate. As soon as malware tries to attack your computer, Microsoft Defender is there to stop it.

Software minimalism

Software minimalism is all a big joke. Why do you need your computer to use 100MB of system RAM idle? Unused RAM is wasted RAM. Microsoft makes sure to leave no RAM wasted, which makes it much better. Unlike suckless, Microsoft makes feature complete software that normal people can use. In fact, suckless is just a software project created by Microsoft's worst employees created to trick Linux users into thinking Linux is unusable, thus getting them to move over to Windows. Microsoft makes sure people join the beautiful land of Windows, where no one falls for memes, and everyone is secure.

Conclusion then. After I found out Windows is better than Linux, I have decided to stop working on my meme projects, and join Bill Gates in helping him build the best operating system for normal people. Linux furries and neckbeards, join the land of Microsoft today, stop using the Matrix meme, come back to Discord, assist Microsoft and the NSA in catching criminals, and become a real member of society today. It's only a $100 operating system.

Alright so I have a brief announcement or something today and that is, I have officially stopped using Gentoo. Yes that's right, the Gentoo elitist is now an Arch cuck. But why, why would you commit such a crime you might say? Well, Gentoo has actually been giving me more and more problems for months now, and it doesn't seem to get any better.

I've had so many dumb issues with Gentoo recently, such as Xft fonts being broken, packages failing to emerge, --depclean removing my entire system, and the final straw, gnome-keyring issues that just do not occur on other GNU/Linux distributions. In case you're not aware, I have been using Arch on my laptop for months now, and while Arch has some annoying issues such as GPG keys constantly breaking pacman when updating, I find that it works much better now.

To make matters worse for Gentoo, syncing the repositories takes a very long time, and it's valuable time that I do not want to spend just because a program is slow and written in Python. Moving over to Arch was not difficult though. I said 'fuck it' yesterday at around 04:00 in the morning, and started installing Arch over Gentoo. Thankfully, as you guys know I have an arch repository containing nearly the same programs as my Gentoo repository (overlay), and as such I was able to install my config files and all my programs using one command. It's super nice, otherwise I would've probably spent much more time on this.

Anyways, as for my overlay, I will probably update it every once in a while using maybe a docker container, but I'm going to be focusing on the arch repository because it's what I'm using. For those of you that actually use Arch, this might be good news for you because it means you will always be able to install my software using pacman. I know that some of you will probably be disappointed about this, because I'm kind of known as a Gentoo user at this point, but I just can't take Portage's stupidity anymore. If you need to however, feel free to remove my feed!

I also took the time to move /home to a separate partition, which is really nice if you want to reinstall quickly. Whatever, that's all I needed to say with this blog post. Have a good day!

2023-03-15

I'm going to keep this one short and to the point. As some of you may know, my domain is going to expire. It is going to expire on the 31st of March 2023, which is not far from today and that's what I'm going to talk about. For those of you that don't know, my website uses a "free" TLD (top level domain). This seemed like a good option last year, but as I want to continue this stuff, it presents a problem. Freenom is the company that provides the .gq TLD, along with a few more domains such as .tk. Freenom has shown themselves to be problematic, and they have done things like taking away domains from people after the websites have become too popular. Renewing their domains is also difficult and annoying, and even then doesn't work all the time for all people.

Because of this, I decided to write this blog post, and to make sure my readers have a place to keep up with me if my website does collapse, I've created a Matrix channel which I recommend you join. You can join it here. You can start with Element, it's all free software unlike the previous Discord server. I don't plan on making this a big thing like Forwarder Factory was, and in fact I don't want that either. This is simply going to be a small place for me to talk to my readers, discuss the website and other things like that. Either way, my domain expires March 31st if I'm unable to renew it. If I manage to renew it, you can continue using the site like normal for an additional year. Otherwise, I'm simply going to purchase a new domain. I do not yet have another domain, which is why I recommend you join the Matrix channel. That's really all I wanted to say, as the writer here I think it is important that you are informed about everything. My website code is all available for free on Codeberg so you can still have that if you want.

Thanks for reading, have a good day!

2023-03-09

So, because this blog post marks blog post number 50, and because the first blog post is 1 year old today, I thought to celebrate I'd do a rewrite of my first blog post, which still holds true, actually more so than when I intially wrote it. Granted, the original blog post is terrible, it was fueled out of frustration and nothing more so let's give the topic the chance it deserves.

As well all know, GNU/Linux is an operating system and it has always been the outcast, it has always been less popular than other operating systems like Windows and macOS. Out of the outcast operating systems like BSD, Haiku and more however, it's pretty popular and it's growing in popularity. While this may seem like a good thing at first, when you actually dig deeper into what that means for GNU/Linux, you'll find many problems and I want to talk about those today. So let's go back into the early days. Linus Torvalds developed the Linux kernel, which was used in combination with the GNU project. This means we now have a completely free software operating system. Great, now we don't have to use spyware nonfree software that doesn't respect your freedom anymore and everything is good for the small userbase. Previously GNU/Linux followed the UNIX philosophy rather closely, which is what made it so great. Of course there were exceptions to this rule, such as X11 (and today Wayland), however most software was minimal, and closely followed the UNIX philosophy like it was a religion, as that was expected out of software.

As GNU/Linux got more mainstream and normies got their hands on it, this freedom, this minimalism, all this stuff that made GNU/Linux so great started to disappear. When normies found this free operating system, naturally being normies they didn't want to actually learn anything about minimalism and free software, and certainly didn't want to enjoy any of the perks of it. Instead of that, they initially whined and complained about how it was different from what they're used to. And we, members of the GNU/Linux community in response did everything in our power to make the "Year of the GNU/Linux desktop" happen. Except..

We didn't. In response to normies complaining, we as a community at large started developing garbage, bloated software that throws everything that makes GNU/Linux and UNIX in general so great in the trash. We're no longer using text streams, we're no longer writing quality software with quality code, instead we're focusing on developing libraries on top of libraries that just add bloat to a project and create huge basically packages of software in an effort to please normies who refuse to appreciate the beauty of UNIX-like operating systems and just wanted to stick to what they're familiar with.

Here's the thing, If you're this kind of person who doesn't want to learn GNU/Linux, you don't want to learn about UNIX-like operating systems and you don't want to spend any time out of your day learning this stuff then why even bother using a new operating system in the first place? At that point, you might as well stick with Windows or macOS. But alright, fine. We can still have our section of the GNU/Linux community where traditional UNIX/Minimalist views are still appreciated, right? Well, no because eventually programmers start writing software which of course depends on all this normie software which is absolutely awful and now it becomes almost impossible to have a functioning system on GNU/Linux without this garbage software.

I haven't given any examples yet, but in my first version of this blog post I referred to Snaps, AppImages and Flatpaks, and while those do still meet the criteria here (although not in the present), I want to give some more examples which might make more sense. First, systemd. systemd is a collection of tools for GNU/Linux, and although many people hate systemd because it is "an init system", it is really a suite of tools. Therefore calling it bloated is not justified. However what is justified is valid criticism towards it. systemd provides a tool named "logind". So many programs depend on this, it is pretty much impossible to have a modern GNU/Linux system without this program installed on your computer. Now, that should be taken with a grain of salt because there are many different implementations of this tool, and those of you that use Gentoo may be familiar with one implementation called elogind. Still, I think this is an excellent example of dependencies that are used so much you cannot escape them.

But there are so many programs like these that we can't really escape, and the cause of these programs existing is usually the same. Normies want "easy" software, so in response we write terrible software which a normie will think is easy because Windows is terrible. However the worst of it came around the time Linus Tech Tips and all these other well known technology "entertainment" channels started covering GNU/Linux and giving it attention. When that happened and Windows/Mac users gave this OS a proper chance, developers around here scrambled to write as much normieware as possible to please these new users in the hopes of converting them into GNU/Linux users. Of course this failed, and just resulted in more terrible software.

I call this the "gaming wave", because suddenly all these gamers (often with NVIDIA graphics cards) came over here, because that's what Linus Tech Tips' fanbase is and wanted to play games. Of course, this failed because despite the effort from the people who play games around here, most GNU/Linux users don't really play games. In fact I barely play games myself anymore. I have nothing against people who play games, but the people who play games on GNU/Linux certainly have some blame to take here.

Lastly, before I end off this blog post I want to mention a few things regarding Wayland. In short, I'm definitely against it and that's for a few reasons. Wayland brings a lot of good things to the table, such as a cleaner codebase, less screen tearing, perhaps HDR support in the future, and so on and all that is fine by me. No complains there. Where the problem starts to show however is from a developer perspective. Yes, the Wayland display protocol is more minimal than X11 (that's not really an achievement) but a lot of that is because the Wayland mess has been moved over to the compositor forcing any developers to write thousands of lines of just absolute junk. This is absolutely terrible, and until the developers of Wayland change direction (highly doubt they will), I'm sticking with X11 until it's no longer feasible to do so.

Either way, that's what I wanted to say, stop using all of this stupid software whenever possible, and become a based GNU/Linux minimalist. I plan on getting a page up on replacements for stupid software which will kind of act as a guide on how to get into GNU/Linux minimalism for those of you that fell for this stupid software. If you have any questions or thoughts, feel free to send me an email.. and have a good rest of your day.