I later decided to take part in it. The requirements were that the photos are licensed under a Creative Commons (CC) license. As I publish most (currently all) of my photography under such licenses, this was not an issue for me. More notably, it was some kind of motivation knowing that now my images can be found and used by anyone on Wikipedia with the appropriate credit.

There were several categories: One main category with a landscape and macro image, which was hosted first on a national level, after which the winners would compete internationally. The second category in which I later won was the special category for environment and human rights.

My image, as you can see below, is a photo of a baby bird which tried to swallow a piece of plastic. I took this image in my garden where my father found the bird. The parents probably found the piece of plastic somewhere in the neighborhood and used it for nest building. It is a strong reminder to take care of your trash and what can happen to the environment around us if we don’t.

I uploaded a couple of images from protected areas and the image I talked about above. The normal images were all from Germany, so I competed there locally. In this local competition, there were many good photos, so my images did not rank especially high. So I had my fun and didn’t think much about the competition. A few months (or so) later, I got a Wikipedia message and mail that my image won in the International Human Rights and Environment competition. I must admit that I was fairly surprised. After the okayish result in the local competition I did not suspect that it would go so well for me in the special category. After seeing the message for the first time I spent some time with validating that it is real and not some crazy spearphishing attempt. But everything seemed perfectly fine. I was really happy that day.

The special category does not have any super crazy prizes, but I got a nice diploma with some Wikipedia goodies. I especially like the pencil holder. Also my laptop now has a new sticker which is always a great plus.

Anyway it was a great competition and I had a lot of fun. I really look forward to participating again in 2026. Maybe I could motivate you to join me and many others.

The camera itself

When I started photographing with my Panasonic G91 I mostly used the full automatic mode. That is pretty easy but not very optimal in my opinion. After reviewing a couple of images I took during that time, I saw that a couple of images had settings that did not make very much sense. The aperture priority mode I tried with this camera made a lot of a difference. In this mode, you set the ISO and aperture and the camera automatically determines the appropriate shutter speed. This mode gives you a lot more control over how the image looks because you set the aperture consciously. I also got a pretty good feeling for which light conditions required which settings, because I chose two of the three myself and had a good look at what shutter speed the camera chose.

Sometime this year I got a new Nikon Z8, which changed a lot for me. I bought three prime lenses instead of a zoom lens, which I had with the Panasonic. Those prime lenses force me into being a bit more creative when taking the shot. Those lenses are a 20mm, a 50mm and a 100mm macro. The 50mm was quite unspectacular for me because it looks like a normal image. The tele lens felt quite natural to me, which was really nice. But I realized that macro was a lot harder than I thought. Even with image stabilizers it’s hard to get your subject into focus and have a nice bokeh without having everything, or mostly everything, blurred out. My wide-angle lens first felt odd, but after using it for a bit, I fell in love with it. I think this is the hardest lens, but I have produced some really cool looking images with it. Overall, I am quite happy with those lenses.

Having no zoom lens is quite another way of photographing. It means you cannot always take the shots you want to because you cannot change your focal length quickly in the field. I often had my other lenses with me, but changing them always takes a bit. But I think maybe that’s a good thing from time to time. So you can take the same route several times and force yourself into thinking a bit out of the box and experiment with different focal lengths.

On my recent trip to Sweden, I used filters for the first time. They are a game changer when photographing landscapes with a tripod. Those smooth images when using an ND filter to photograph water are just awesome. I think I created one or two good waterfall photographs. I also tried a CPL filter and the combination of ND + CPL, but do not really know when to use what. I am still trying to figure that out, so I take most of the time a shot with and without CPL.

Photomanagement

I am a Linux user because it is the only available option which offers a good open source experience with a lot of software. And being open source and privacy-friendly are requirements for me to protect my freedom. Therefore classical image editors like Lightroom are out of the question for me. Firstly, because they are neither open source nor do they work on my Fedora system (or any other Linux system without dirty workarounds). And secondly, because I really do not like Adobe and its very ugly subscription model.

But that’s no problem at all because there is a similar and in some cases even better, alternative to Lightroom called Darktable. It is free and open source software (FOSS) and available for all of the big operating systems. It offers the capability to manage big libraries of photos and edit them in a non-destructive way.

I have all my images in a library folder which is synchronized to all my devices using Nextcloud (also FOSS), but other tools like Syncthing could be used. Ensuring all my photos are only in one place and synchronized assures that I do not have duplicates or lose something because it was not backed up correctly.

If I come back from a shoot and want to save my images, I load them into a new folder under the library folder. I give every shoot a name to know what I can expect. Those shoot folders are saved in the following format: library/<year>/<shootName>

After saving all my files, which are now already safely backed up, I go through them and pick what is going to be deleted and give the rest of the images a rating to prioritize them while editing. I work with stars for the rating.

I then edit first all five-star images and then the four-star ones. I previously did only the sorting of the images right after the shoot, but this had the disadvantage that I needed to do a lot of work in the last few weeks to edit all of the photos I wanted to. For the future, my plan is to edit them right away after the shoot to have only small bits of work and not so much at once. A nice bonus is that if you edit images not long after the shoot, you still have in mind the intention you had while shooting.

Besides the stars, I also use colors to manage my photos. I, for example, use red for the images I have already published/exported and purple for private images I do not want to export for now — if, for example, a person I know is on them, but they do not want to be online.

Editing

After editing all my photos, I seem to have built a habit about which modules I use most on my images. And what I am most happy about is that I can see that my edited photographs look much better now than in the beginning, where I struggled to be better than the JPG produced by the camera. I am sure I can learn a lot more in this area, but think that needs time and maybe some guidance. But for now, I want to share with you how I am editing my images.

Base style

I have a style in Darktable which I apply to every image I start editing and go from there. In this style I activate color balance RGB and increase the global brilliance and global saturation. I activate denoise (profiled) and local contrast at the default settings and set the color calibration to “as shot in camera.”

Manual edits

I then edit the photo manually to fit my liking. I first try haze removal and take a look if it is improving the image. Most of the time I then increase the local contrast a bit and sometimes add a bit of contrast over the filmic RGB module. But that’s not that often happening. After that, I check if the shadows and highlights module helps the image and play around with the settings of it a bit. In color balance RGB I try to set everything so the image feels right. Most of the time only brilliance and saturation, but sometimes also chroma. I use crop and rotate the image to make it as pleasing to my eye as possible. If there are any smudges on the camera lens, I remove them with retouch. Sometimes I also use sharpen, but I do it less and less.

Exporting

I publish all my images to my website and syndicate them from there to all social media platforms. I have changed quite a bit in the process since my last automation posts, but that is a topic for another time. For now what is important is that I publish for the web. Therefore, I do a few things before publishing, like setting some notes on the image which describe what can be seen. That information is later used to set an alt tag which is used for people with screen readers, like for example some blind people use. Besides that, I also add tags which are used later as hashtags for social media. I seldom set a description, which in my case gets displayed as a text next to the image. But in some cases, I want the viewer to have some information and then I can provide it with that. I also set publisher and rights so that all the important metadata is set.

I hope you could learn something from my reflections about my photography journey or at least have found it interesting to read. I will continue to learn both getting better photographing skills and editing skills and maybe write about it in the future. I hope I can see some progress then 😄

The Tor network empowers people to access the uncensored internet from many places around the world. It provides a way for all of humanity to access information in a free and open manner. It includes many tools and options to circumvent censorship and even active measures taken against it. Tor bridges or the Snowflake browser add-on, for example, help people in censored countries connect to Tor even when the known entry node IPs are blocked by the state.

How Tor gives you freedom of speech

But that’s only half of it. The freedom to acquire information is arguably one of the most fundamental qualities of a good life. Freedom of expression is also essential for a free and fulfilling life. Tor also enables people who have to fear the consequences of an authoritarian state to publish their opinions as anonymously as possible and therefore protect those freedoms.

How you can use Tor

For those of you not very tech-savvy, here’s a little summary of how Tor works and how you can access the “darknet”.

If you want to start browsing the Tor network and the “normal” World Wide Web, you need a special browser. This browser is called the Tor Browser and you can download it here. With this browser installed, you can use it like any other browser.

You might notice that it is a bit slow, but this is because of how the Tor network works. Basically, your whole traffic is encrypted multiple times like an onion. That’s also where the name Tor comes from — The Onion Router. This traffic is then sent over multiple computers, so your initial location can only be traced back with difficulty and under very specific conditions. This enables the end user to stay private.

There is also a new type of top-level domain available if you are using the Tor browser. (A top-level domain (TLD) is something like .com, .org, .net, .de, .au, .nz, …) This TLD is .onion and can only be accessed over the Tor network. You can get a domain like that for free and they look kind of weird. Here is mine, for example: lnadevwj2vzomixiunv7i4lahwpoxh6zw56cxbce3uui5ijmwt4czpyd.onion. That is because there need to be many different ones if you want to give them out for free.

These .onion domains allow the creator of the website to hide their IP address and therefore stay (sort of) “anonymous” — similar to the user, but the other way around. This is, like I said before, needed if you want to express yourself from within a repressive country. But even today it is needed for activists, journalists, whistleblowers and many more groups of people needed for a well-functioning and free democracy.

Why does that concern me?

Our world gets more autocratic and dangerous day by day. Looking at you, USA… But even here in Europe, things look bad. Far-right-wing parties with high vote counts and corrupt politicians, for a start. More worrying is that even the more democratic parties are applying more and more autocratic tools like mass surveillance and strengthening the police… Still, the situation in America is way worse — not even speaking of all the other parts of the world like China or Russia, which are the authoritarian powerhouses of this world.

With all this repression, there is a big need in the world for tools like Tor and they need to be supported as much as possible. I wanted to check out how difficult it is to host a website — in my case, this one — on Tor, or as the mainstream calls it, “the darknet”. As it turns out, it is extremely easy, as you’ll see in one of my upcoming blog posts about how my setup works. But for now, let’s just say you can skip a couple of steps compared to a traditional website. You don’t need to buy a domain — you just get one for free. You also don’t need to worry about any firewalls or anything similar. Tor goes straight through it. Remember, Tor was designed to thrive in a censored environment.

With the knowledge to host a website over the Tor network and the information on how easy it is broadly available, we are better prepared for a reality that isn’t as fine as our current situation (in which many people currently live and suffer under).

So for me, it was an experiment to see how this technology works and to gain the knowledge — and hope I never need it. My website is the same here and on the darknet, so I have no anonymity boost because of it. But after all, it’s also just very cool and interesting to me. Censorship-prevention technologies have fascinated me since like forever.

How you can learn more about this topic

There are a couple of good sources about the threat of authoritarianism, Tor and how it can help. The most obvious source is the website of Tor itself. There you can find a lot of information about how Tor works and how to use it. Also consider going through the blog posts on their page to see news and that sort of thing.

The Electronic Frontier Foundation (EFF) has a section about free speech and a bit about Tor.

There are many other resources out there — explore, read and stay curious. The more people understand and support tools like these, the more resilient we become.

I also wrote a post in which I explained how to automate posts to Pixelfed (a Fediverse platform), which is quite similar to this one. I might refer to that post from time to time because the process is quite similar.

This post might be a bit technical if you have no previous experience with coding / tech.

POSSE

So, first of all, why do all this? For me, the answer is simple: I have been getting into the IndieWeb bubble for a while. As part of it, you want to build your own website, which you control and have full power over. Your website is your little garden where you put all your stuff. But because most people won’t just visit your website directly, you need a way to get your content to them. For this, automation is key.

You host all your content on your page and then build scripts and little bots that take the content from your webpage and syndicate it wherever you want. Whether it’s the walled gardens of big tech, the Fediverse or Bluesky doesn’t matter. You just post to your website and your bots do the rest. This principle is called Post On your Own Site Syndicate Elsewhere or POSSE for short.

I might write a detailed post about the IndieWeb and POSSE in the future, so stay tuned!

My data source - RSS Feed

As I already explained in my Pixelfed Automation post, I have an RSS feed that contains all the data I need for publishing my images. Specifically, this includes the image URL, description, alt text and hashtags.

Your data source may vary if you have an API or something similar to access the required data. Personally, I like the idea of having an RSS feed because users of my webpage can follow the same feed and use an RSS reader to consume my content.

The Python script

Now, onto the actual automation. I used Python because I already had my Pixelfed script, which I could reuse a lot from.

There are a couple of code blocks that I didn’t really touch. For example, the parts responsible for retrieving the image from my website, selecting which image to publish and notifying my API about the images that are now online.

Since I’ve covered these steps before, I’ll jump straight to the interesting part: how to publish to Bluesky. (If you want to know the details about the other steps, you can read them here.)

Publish to Bluesky

This is where it gets interesting because we’re doing the actual publishing. First of all, there is a good Python library for Bluesky / ATproto called atproto. You can install it with the following command:

pip install atproto

After installing the right package, we can look at the code itself. First, we need a client where we pass our email and PAT (I explain how to generate one in the next section). This is enough to authenticate with Bluesky.

Next, we prepare our post. For this, I use the TextBuilder provided by the package to format links and hashtags correctly. After preparing our text/caption, we can use the send_image or send_post method, respectively. And that’s pretty much it! Quite easy when using the library.

from atproto import Client
from atproto import client_utils

BLUESKY_PAT = os.environ.get('BLUESKY_PAT')

bsClient = Client()
bsClient.login(
    login="bluesky@lna-dev.net",
    password=BLUESKY_PAT,
)

# [...]

def publish_entry(entry):
    caption = client_utils.TextBuilder()
    caption.text("More at ")
    caption.link(text="https://lna-dev.net/en/gallery", url="https://lna-dev.net/en/gallery")
    caption.text("\n\n")

    for element in entry.tags:
        caption.tag("#" + element.term, element.term)
        caption.text(" ")

    media_url = entry.media_content[0]["url"]
    alt_text = re.search('alt="(.*?)"', entry.summary)
    alt_text = alt_text.group(1) if alt_text else "Alt not found"

    bsClient.send_image(
        text=caption,
        image=download_image(media_url),
        image_alt=alt_text,
    )

    published_entry(entry.title)

How to get your Bluesky PAT

To generate a Personal Access Token (PAT), also called an App password, go to Settings => Privacy and Security => App passwords or click here.

Now you can just click Add App Password and copy the text. That’s it! You can now add this to your script or environment variables.

Full code

from io import BytesIO
import os
import re
import sys
import feedparser
from datetime import datetime
import time
import random
import requests
from atproto import Client
from atproto import client_utils

BLUESKY_PAT = os.environ.get('BLUESKY_PAT')
API_KEY = os.environ.get('API_KEY')

bsClient = Client()
bsClient.login(
    login="bluesky@lna-dev.net",
    password=BLUESKY_PAT,
)

# Function to filter entries based on the name list
def filter_entries(entries, name_list):

    # Temp skips (for example if this image does not fit currently)
    # name_list.append("P1002496.JPG")

    return [entry for entry in entries if entry.title not in name_list]

def get_already_uploaded_items():
    try:
        response = requests.get("https://api.lna-dev.net/autouploader/bluesky")
        if response.status_code == 200:
            string_list = response.json()
            return string_list
        else:
            print(f"Failed to fetch data from API. Status code: {response.status_code}")
            sys.exit(1)
    except Exception as e:
        print(f"An error occurred: {e}")
        sys.exit(1)

def published_entry(entry_name):
    requests.post(f"https://api.lna-dev.net/autouploader/bluesky?item={entry_name}", headers={"Authorization": f"ApiKey {API_KEY}"})

def download_image(image_url):
    response = requests.get(image_url)
    if response.status_code == 200:
        return BytesIO(response.content)
    else:
        print("Failed to download image!")
        sys.exit(1)

def publish_entry(entry):
    caption = client_utils.TextBuilder()
    caption.text("More at ")
    caption.link(text="https://lna-dev.net/en/gallery", url="https://lna-dev.net/en/gallery")
    caption.text("\n\n")

    for element in entry.tags:
        caption.tag("#" + element.term, element.term)
        caption.text(" ")

    media_url = entry.media_content[0]["url"]
    alt_text = re.search('alt="(.*?)"', entry.summary)
    alt_text = alt_text.group(1) if alt_text else "Alt not found"

    bsClient.send_image(
        text=caption,
        image=download_image(media_url),
        image_alt=alt_text,
    )

    published_entry(entry.title)

# Parse the RSS feed
feed_url = 'https://lna-dev.net/en/gallery/index.xml'
feed = feedparser.parse(feed_url)

# Filter out entries with specific names
specific_names = get_already_uploaded_items()
filtered_entries = filter_entries(feed.entries, specific_names)

if not filtered_entries:
    print("No entries available after filtering.")
else:
    # Calculate time differences considering only month, day, hour, minute, and second
    current_time = datetime.now()
    closest_entry = None
    skipped_entries = []
    min_difference = None
    for entry in filtered_entries:
        if entry.published_parsed.tm_year == 0 or entry.published_parsed.tm_year == 1:
            skipped_entries.append(entry)
            continue  # Skip entries with invalid year
        temp = time.mktime(entry.published_parsed)
        published_time = datetime.fromtimestamp(temp)
        difference = abs(current_time.replace(year=published_time.year, tzinfo=None) - published_time)
        if min_difference is None or difference < min_difference:
            min_difference = difference
            closest_entry = entry

    if closest_entry is None:
        print("No valid entries available after filtering.")
    else:
        # Get all entries published at the same time as the closest entry
        closest_entries = [entry for entry in filtered_entries if entry.published == closest_entry.published]
        for element in skipped_entries:
            closest_entries.append(element)

        # Select a random entry from the closest entries
        random_entry = random.choice(closest_entries)

        # Print the selected entry
        print("Random entry closest to the current date/time (ignoring year):")
        print("Title:", random_entry.title)
        print("URL:", random_entry.link)
        print("Published Date:", random_entry.published)

        publish_entry(random_entry)

Schedule the script

After creating such a script, you need to trigger it somehow. If you are using Kubernetes, you may want to check out the Pixelfed post, which explains how to set up a Kubernetes CronJob.

For those who just have a simple server, I recommend setting up a Linux CronJob to trigger the script periodically.

Nginx Proxy Manager

Using the default charts in TrueNAS Scale, your application can only be exposed on a high port. Accessing your apps via such a weird port and without a proper domain isn’t cutting it. Is it? Therefore you can run a reverse proxy that manages TLS encryption and directs traffic for each subdomain to its respective app, without needing a special port in the URL.

Until now, I had always used a Traefik proxy when working with Kubernetes, but I found this cool project that seemed to fit perfectly. It’s called Nginx Proxy Manager, or NPM for short. With NPM, you can set up a reverse proxy and also manage your TLS certificates using Let’s Encrypt.

Installation

First of all, we can’t install this app the way we would normally install an app. It is in the default app catalog, but this version can only be hosted on port 9000. Instead, we’ll use the Docker image to deploy it. This won’t make any difference, but we can use our own IP address for it, which also means we can use all ports.

To start, go to the app catalog and click Custom APP in the top right corner. There, you can configure everything. I’ll provide the required settings below.

After installing the app, you can access it via its IP address on port 81. The default username is admin@example.comand the password is changeme. Change them immediately!

Setting Up TLS

Once everything is set up and you’ve changed your password, you’ll see something like this. First of all, I recommend setting up your TLS certificate if you have a domain. If you don’t have a domain, you can still upload a custom certificate.

Click on the SSL Certificates tab to see a list of all the certificates you’ve set up. If you click the button in the top right, you can create a new certificate. Here, you can choose between the Let’s Encrypt certificate authority or upload a custom certificate if you’re using a local domain. But if you can get a domain, I recommend doing so. I will proceed with the setup instructions for Let’s Encrypt.

If your server is reachable from the public internet, you just need to enter your domain name and agree to the Terms of Service. This will spin up a local webpage to verify that you actually own the domain you enter.

You can also set up a TLS certificate for all subdomains by entering *.example.com.

If your server is not accessible from the public or if you want to use another method, you can choose the DNS challenge. NPM has a couple of DNS providers which you can choose from. Take a look at the list and search for your DNS provider.

You just have to enter the API token or log in another way specific to your provider. NPM will then modify the DNS records to prove that you own the domain you have provided.

If you complete any of these methods successfully, you’ll get your SSL certificate.

Setting Up Your Apps

Now we want to configure the Nginx Proxy Manager to relay traffic from specific domains to a specific TrueNAS Scale app. To do this, go to Dashboard => Proxy Hosts.

Here, you’ll see an overview of all the hosts / apps you’ve configured. On the top right, you can add a new host.

In this window, you can finally configure access to your app. You need to enter the domain where you want your app to be available, choose the scheme (http/https) your app runs on (probably http)and enter the port your application uses.

The hostname of your app is its internal DNS entry in the Kubernetes cluster. It usually follows this pattern: <app-name>.ix-<app-name>.svc.cluster.local. So, for Jellyfin, it would be: jellyfin.ix-jellyfin.svc.cluster.local.

You can find the correct port in the app’s configuration or use the default port.

These are the values for your app running in TrueNAS Scale, not the values for accessing the app publicly!

I also recommend enabling Websocket Support and Block Common Exploits.

At this point, your app will be accessible via your domain, but one final step is needed to allow requests over HTTPS. You just have to go to the SSL tab and select the certificate we set up earlier.

After selecting your certificate, I recommend enabling all the available options (Force SSL, HTTP/2 Support, HSTS Enabled, HSTS Subdomains).

Once you click save, the host is set upand your app should be accessible via your domain and the HTTPS protocol.

If you want to point one domain to your Nginx Proxy Manager UI, you can just point it to http://localhost:81.

Footnotes

Hardware

(Looks a bit messy, I know 😅 But I somehow like it 😜)

As you can see, I am using an old PC as my server. This has the advantage that I only needed to buy the hard drives to support my storage needs, but the downside is that electricity consumption is rather high. Last time I measured with all my apps running, it consumed about 60W. A fresh build could be optimized for electricity consumption, which can save you a lot of money if you want the server to run 24/7. ¹

I chose not to do a hardware RAID because I am using the ZFS file system. I will explain this in detail in a dedicated part.

ECC memory?

I unfortunately do not have ECC RAM, but if you can get it, I would recommend it. Error Correction Code (ECC) RAM is able to correct wrong bits, which makes the system more secure against some hardware attacks and especially more reliable. It is not a complete dealbreaker not having it, (especially because it’s kind of rare in the consumer world at the moment) but having it is a nice addon.

Uninterrupted Power Supply (UPS)

I bought a UPS to support my server in case of power outages. The UPS has a battery that can keep my server alive for about 15 minutes, then it gives a signal to the server, which is configured to shut down before the UPS battery runs out. This ensures that most power outages never cause a problem, as they are shorter than the battery time and if the power is out for a while the server shuts down gracefully.

Why I chose TrueNAS Scale

Now to, in my opinion, the most important part: The operating system. I chose TrueNAS Scale for a couple of reasons. First of all I wanted something that is Open Source. I also wanted to run apps on the system and definitely needed some sort of RAID / software RAID. TrueNAS Scale has it all. It is based on Linux and led by the company iXsystems. ² For applications, it supports Docker and Kubernetes, as well as its own VMs. I am actually not really using the VMs yet, but I really like Kubernetes and also Docker. So this was great news for me. These technologies allow you to run basically any app you like on it because most apps are or can be containerized. In addition to this, the system uses OpenZFS as the file system, which is pretty cool in my opinion. We will take a look at it in the next part.

RAID

As I previously mentioned, I am not using a classical RAID system. Instead the ZFS file system which is used by TrueNAS Scale, has something similar to a software RAID built into it.

But first of all, to bring everyone on the same level, I want to explain what RAID actually is. RAID stands for Redundant Array of Independent Disks and as the name suggests brings redundancy into data storage. There are several versions of RAID (0, 1, 5, 6 are the most important ones). RAID 0 just stripes the data across multiple disks and does not provide any redundancy. RAID 1 mirrors every disk on another one so half of the disks could fail without losing any data. The last two versions are the important ones for this blog post. They both work similarly: First the data gets striped like in RAID 0, but a parity part is also calculated, which can be used to recover the data if a drive fails. With RAID 5 you can lose one disk without losing data and with RAID 6 you can lose two disks without an issue. The disadvantage of RAID is that you need more disks because of the redundancy.

OpenZFS

Now let’s talk about ZFS, which is an awesome file system in my opinion. It provides a set of features that make it especially interesting for server operation and other systems where correct data storage is important. A few of its features are RAID-Z (which I’ll discuss later), data compression, data deduplication, snapshots and self-healing. All of these features are very interesting for building a storage-focused server like the one I am building.

RAID-Z is the most important feature of ZFS in my opinion. It allows me to run the server without a physical RAID controller. It works a bit differently from RAID, which brings better performance and it also has the self-healing ability ZFS is known for, all while not needing a physical RAID controller anymore. This is actually only possible because there is no RAID controller and the file system can manage the disks directly. It is not recommended to use ZFS in addition to a hardware RAID because of that.

Setup of the OS

The installation of the OS is pretty straightforward. You can follow the installation guide on the developer’s website.

If you set everything up, this is how the web UI looks. Here you can control pretty much everything about the system graphically. In addition to the UI, I would recommend setting up an SSH connection so you can use the command line on your system. You can do that under credentials => users => upload SSH key.

Under datasets you can set up different folders with different permissions, purposes, shares and much more. You can decide if you want to encrypt your data (you want to 😉) and how you want to do it. There are two options. With the simplest option, a key gets generated and you just have to save it somewhere safe as a backup, while the server stores it securely. But if you are like me and a bit paranoid when it comes to disk encryption, you can also use a really strong password. The difference is that you have to enter this password after every restart. This provides the security that if your system is shut down, it is safe against a lot of hardware attacks.

How I move files

TrueNAS Scale provides you with a few kinds of file shares. I tried them all but did not really like any of them, which actually makes it a lot simpler for me. I am using SSH in my Gnome file explorer if I want to move files or I just do it over the command line. This works perfectly fine for me.

If you want to use shares, you are able to use SMB, NFS and iSCSI to do so. Just play around with it and see what you like most. For me, it’s the good old SSH.

What apps I run

Now to the most interesting part, in my opinion. I want to run apps that support me in my day-to-day life and provide value. This is why I do all of this.

TrueCharts and why I do not use them anymore

But first of all, we need to talk about TrueCharts. They are a pretty big third-party app catalog or at least they were for a very long time. They now said that they are going to drop support for TrueNAS Scale because they claim iXsystems will remove Kubernetes from the OS in a future update. I am not really sure about that because I haven’t read anything significant. But I think sticking with the original apps is not that bad either way. It’s a bit different to set up, but I will guide you through it here.

I also want to mention that I had a few problems using charts from TrueCharts. I do not want to blame them for it, but I think they are less stable than the original ones. But they have advantages like more settings and less performance overhead, so I think the guys from TrueCharts still did a really good job.

Install an app

I do not want to use file shares for everything. That is not very convenient. I want to use an app that works like all the other file cloud providers. This is why I host Nextcloud on my NAS. This is a really cool private cloud software that manages everything like files, contacts, calendars and the list goes on and on. I will talk a bit more about it in a future post. ³ But for now, let’s take a look at how to install an app like that.

The process is actually pretty simple. You can just choose your app from the catalog, which you can open with the discover button.

Here you can choose from many different apps or provide your own if you want to create something not in the default apps. If you have found an app you want to install, you can click on it and configure the app with everything the app allows you to change. Here the TrueCharts apps are a lot better because you can configure way more. But the default apps have a few settings as well and are much simpler. An important thing to keep in mind is that there is a limitation with the default apps, so you cannot use ports below 9000.

If you are finished with configuring, it is just as easy as pressing the install button. After a few minutes, the app is running and you can access it over the port you chose.

The End

You now know the basics of TrueNAS Scale. I hope you took a little bit of information from this post and I hope to see you in the next one of this series😄

There are many reasons someone would want to have a home server. In this post, I want to explain why I chose to build a home server and in the following ones, I will show you how I did it and how you can do it too.

Privacy and Independence

For me, there are a few main reasons why I wanted to get started with self-hosting. I think my journey began about two years ago in 2022 when I first played around with a Synology NAS. This helped me a bit with some of the goals I had. Having a Synology NAS improved my independence, especially from the big tech nightmares and therefore also improved my privacy. But after a while, I felt that something wasn’t quite right with this setup. First, the Synology software is not Open Source and therefore there are still privacy concerns. (I will cover why this is so important to me in a future post.) Also, Synology is a Taiwanese company and the situation with China was worrying me. (There would be a lot of bigger problems in tech, but it was still concerning.)

So the next step was building my own NAS / home server with custom Open Source software. I explain this in another post of this series. For now, let’s just say I built my own server about a year ago in 2023 and now I have all my data at home in an environment I trust and am able to control fully. So I achieved a lot of independence from the shady big tech companies.

Cost

Cost can be an advantage or disadvantage if you start to self-host. On one side, you have to pay for your hardware and the electricity your server consumes, but on the other side, you can cancel a couple of subscriptions which are also pretty expensive. For example, you are probably using some sort of cloud storage. (Or at least you should be using something like that in my opinion. ¹ )

Having a bit of data in such storage can have high costs. For example, buying OneDrive, which is included in the Microsoft Personal subscription, costs about $6.99 a month.² This price only includes 1TB. But if you have large amounts of data, this can get very expensive. To look at another example, Google’s cloud storage costs 9.99€ a month for 2TB.³ Other cloud storages, like a hosted Nextcloud, might even be more expensive.

You also have to keep in mind these are only costs for one service. On your server, you can host a couple of services you need and even share those and also the costs.

Because of all this, you save a bug in my opinion if you start self-hosting and replacing the services you pay for with your own server. But this can vary from person to person.

Just to mention it: OneDrive and a lot of other big tech tools scan your files for illegal content and use filters that might report you to law enforcement. These tools are known to make mistakes and so an image of your child on the beach can lead to your Microsoft account being suspended in the best case and a meeting with the local police in the worst case. Something like that will never happen if you are self-hosting. Be aware!

Knowledge

Another good point for having a home lab is all the knowledge you gain from it. You have to think about the hardware, set everything up physically, learn about RAID, about the operating systems and the software you are running, not to mention security and setting up a safe environment. There is a lot to learn on this journey!

And the good thing here is this is not a one-time thing. You can learn a lot as time goes on. Every now and then, if you feel motivated, you can play around with some settings or try something new.

This knowledge can also pay off in your job as you gain experience you maybe wouldn’t have otherwise. Personally speaking, I learned most of the things I know about IT, especially programming and DevOps, while building my own things. It is just way more motivating building the things you want than just learning by doing exercises you do not care about.

Helping others

Last but not least, I want to mention a small point I think is notable. If you are building all of this for yourself, it is really easy to give a few other people access to the services you are running. So you can help out your friends and family to have better privacy and generally speaking all of the benefits I was talking about. ⁴

I started with Mastodon as my first account in the Fediverse. After a while, I found out about Pixelfed and created my account there. I kept using it for a while and even posted from time to time. My problem with posting to Pixelfed was the lack of a scheduler. I want to post regularly, but I do not want to login every day and make a post manually. This feature was even announced but never finished. Even today, this is not implemented. There is also a GitHub issue discussing this if your interest goes deeper. In the following post by Pixelfed, you can see the announcement.

There are some post schedulers for Mastodon out there. I tried using them with Pixelfed, but nothing worked properly. I even tried the client-side automatic upload feature of Fedilab, which posted immediately instead of at the given time. This surely was a bug I could have reported or fixed myself (because Fedilab is FOSS). But I wanted to make things more automatic anyway.

I do not want to complain about this. It is totally fine. There are a lot of other things that need to be done in Pixelfed and the Fediverse as a whole. But for me, it meant I needed to implement something on my own.

Requirements

So to solve this, I needed something which can somehow talk with my Pixelfed server and make a post there. I also needed a way to know which posts I want to make. This information must include some metadata like the date taken and definitely an alt text and tags to display in Pixelfed. Another thing to keep in mind is that I needed something which “remembers” the state of my postings. Basically, a list in which each post gets added if it is uploaded successfully. And finally, I needed some sort of mechanism which can schedule the execution of the code.

The automation

RSS feed

So first of all, I have a photography page which has an RSS feed. I modified the feed of the page to contain an entry per image I have uploaded there. I am also using Hugo there. Therefore I wrote this little Hugo rss.xml.

{{- $authorEmail := site.Params.author.email -}}
{{- $authorName := site.Params.author.name }}

{{- $pctx := . -}}
{{- if .IsHome -}}{{ $pctx = .Site }}{{- end -}}
{{- $pages := slice -}}
{{- if or $.IsHome $.IsSection -}}
{{- $pages = where $pctx.RegularPages "Params.private" "ne" true }}
{{- else -}}
{{- $pages = where $pctx.Pages "Params.private" "ne" true }}
{{- end -}}
{{- $pages = where $pages "Params.rss_ignore" "ne" true -}}
{{- $limit := .Site.Config.Services.RSS.Limit -}}
{{- if ge $limit 1 -}}
{{- $pages = $pages | first $limit -}}
{{- end -}}
{{- printf "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>" | safeHTML }}
<rss version="2.0" xmlns:media="http://search.yahoo.com/mrss/" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>{{ if eq  .Title  .Site.Title }}{{ .Site.Title }}{{ else }}{{ with .Title }}{{.}} on {{ end }}{{ .Site.Title }}{{ end }}</title>
    <link>{{ .Permalink }}</link>
    <description>Recent content {{ if ne  .Title  .Site.Title }}{{ with .Title }}in {{.}} {{ end }}{{ end }}on {{ .Site.Title }}</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>{{ site.Language.LanguageCode }}</language>{{ with site.Params.author.email }}
    <managingEditor>{{.}}{{ with $authorName }} ({{ . }}){{ end }}</managingEditor>{{ end }}{{ with $authorEmail }}
    <webMaster>{{ . }}{{ with $authorName }} ({{ . }}){{ end }}</webMaster>{{ end }}{{ with .Site.Copyright }}
    <copyright>{{.}}</copyright>{{end}}{{ if not .Date.IsZero }}
    <lastBuildDate>{{ (index $pages.ByLastmod.Reverse 0).Lastmod.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</lastBuildDate>{{ end }}
    {{- with .OutputFormats.Get "RSS" -}}
    {{ printf "<atom:link href=%q rel=\"self\" type=%q />" .Permalink .MediaType | safeHTML }}
    {{- end -}}

    {{- range $pages }}
    {{- if not (in .Path "/archive/") -}}
    {{ range .Resources.ByType "image" }}

    <item>
      <title>{{ .Name }}</title>
      <link>{{ .Permalink }}</link>
      <pubDate>{{ .Exif.Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</pubDate>
      {{- with $authorEmail }}<author>{{ . }}{{ with $authorName }} ({{ . }}){{ end }}</author>{{ end }}
      <guid>{{ .Permalink }}</guid>
      <media:content url="{{ .Permalink }}" type="image/jpeg"/>
      <description>
        <img src="{{ .Permalink }}" alt="{{ .Params.Alt }}"/>          
        {{- if ne .Title .Name -}}
        <p> {{ .Title }} </p>
        {{ end }}
      </description>
      {{ range .Params.Tags }}
      <category>{{ . }}</category>        
      {{- end }}
    </item>
    {{- end -}}
    {{- end -}}
    {{ end }}
    
  </channel>
</rss>

That done, I managed the metadata of all my images in the Hugo config file and wrote an alt text and tags for all my images. (Must admit… an LLM helped me a bit with that. This made the process a lot faster, but the quality is also just okay.)

My personal API

I even wanted to create an API for this page before this little project. So I created a new API written in go. There I implemented a few endpoints which can save and read a list of filenames from and to MongoDB. I am using MongoDB because of the easy use and their free cloud storage. I will probably change that to something self-hosted in the future, but for now, it does its job. (I am running a K8s cluster with broken local storage right now. Need to fix this first.)
Oh, and I also made the POST endpoint protected by an API key so no one unauthorized can alter my data😉

Now having an API which knows which images have already been posted, I could continue to the script interacting with Pixelfed.

The Pixelfed Script

For writing the script, I went with Python. I am having mixed feelings about Python. On the one hand, I really dislike the way it is handling types (it doesn’t lol) but on the other hand, you can quickly make basic things work. So I went the (for me) experimental way and chose Python as my way to go.

I created this basic script which is handling all the stuff needed to create the post and make all the API and RSS handling. I go into detail on some of the methods and bits of code I find most important but I have the full code provided below if you are interested.

from io import BytesIO
import os
import re
import sys
import feedparser
from datetime import datetime
import time
import random
import requests

PIXELFED_INSTANCE_URL = 'https://pixelfed.de'
PAT = os.environ.get('PIXELFED_PAT')
API_KEY = os.environ.get('API_KEY')

# Function to filter entries based on the name list
def filter_entries(entries, name_list):

    # Temp skips (for example if this image does not fit currently)
    name_list.append("P1002496.JPG")

    return [entry for entry in entries if entry.title not in name_list]

def get_already_uploaded_items():
    try:
        response = requests.get("https://api.lna-dev.net/autouploader/pixelfed")
        if response.status_code == 200:
            string_list = response.json()
            return string_list
        else:
            print(f"Failed to fetch data from API. Status code: {response.status_code}")
            sys.exit(1)
    except Exception as e:
        print(f"An error occurred: {e}")
        sys.exit(1)

def published_entry(entry_name):
    requests.post(f"https://api.lna-dev.net/autouploader/pixelfed?item={entry_name}", headers={"Authorization": f"ApiKey {API_KEY}"})

def download_image(image_url):
    response = requests.get(image_url)
    if response.status_code == 200:
        return BytesIO(response.content)
    else:
        print("Failed to download image!")
        sys.exit(1)

def publish_entry(entry):
    caption = "More at https://lna-dev.net/en/gallery\n\n"

    for element in entry.tags:
        caption += '#' + element.term + " "

    mediaResponse = upload_media(entry)
    publish_post(caption, mediaResponse)

    published_entry(entry.title)

def upload_media(entry):
    media_url = f'{PIXELFED_INSTANCE_URL}/api/v1/media'
    headers = {
        'Authorization': f'Bearer {PAT}',
        'Accept': 'application/json'
    }
    files = {
        'file': download_image(entry.link)
    }
    data = {
        'description': re.search('alt="(.*?)"', entry.summary).group(1)
    }
    response = requests.post(media_url, headers=headers, files=files, data=data)
    if response.status_code == 200:
        return response.json()['id']
    else:
        print("Failed to upload media.")
        sys.exit(1)

def publish_post(caption, media_id):
    if caption.strip():
        post_url = f'{PIXELFED_INSTANCE_URL}/api/v1/statuses'
        headers = {
            'Authorization': f'Bearer {PAT}',
            'Accept': 'application/json'
        }
        data = {
            'status': caption,
            'media_ids[]': media_id
        }
        response = requests.post(post_url, headers=headers, data=data)
        if response.status_code == 200:
            print("Post published successfully!")
        else:
            print("Failed to publish post!")
            sys.exit(1)
    else:
        print("Caption cannot be empty.")
        sys.exit(1)

# Parse the RSS feed
feed_url = 'https://lna-dev.net/en/gallery/index.xml'
feed = feedparser.parse(feed_url)

# Filter out entries with specific names
specific_names = get_already_uploaded_items()
filtered_entries = filter_entries(feed.entries, specific_names)

if not filtered_entries:
    print("No entries available after filtering.")
else:
    # Calculate time differences considering only month, day, hour, minute, and second
    current_time = datetime.now()
    closest_entry = None
    skipped_entries = []
    min_difference = None
    for entry in filtered_entries:
        if entry.published_parsed.tm_year == 0 or entry.published_parsed.tm_year == 1:
            skipped_entries.append(entry)
            continue  # Skip entries with invalid year
        temp = time.mktime(entry.published_parsed)
        published_time = datetime.fromtimestamp(temp)
        difference = abs(current_time.replace(year=published_time.year, tzinfo=None) - published_time)
        if min_difference is None or difference < min_difference:
            min_difference = difference
            closest_entry = entry

    if closest_entry is None:
        print("No valid entries available after filtering.")
    else:
        # Get all entries published at the same time as the closest entry
        closest_entries = [entry for entry in filtered_entries if entry.published == closest_entry.published]
        for element in skipped_entries:
            closest_entries.append(element)

        # Select a random entry from the closest entries
        random_entry = random.choice(closest_entries)

        # Print the selected entry
        print("Random entry closest to the current date/time (ignoring year):")
        print("Title:", random_entry.title)
        print("URL:", random_entry.link)
        print("Published Date:", random_entry.published)

        publish_entry(random_entry)

So let’s start with the retrieval of the RSS data. To simplify this for me, I used the feedparser library here. With that, I have access to all the data of the RSS feed in a better-structured way.

With this simple API call, I retrieve the already uploaded posts from my personal API I mentioned above. With this data, I can filter out any entries in the RSS feed which I don’t need to upload anymore.

def get_already_uploaded_items():
    try:
        response = requests.get("https://api.lna-dev.net/autouploader/pixelfed")
        if response.status_code == 200:
            string_list = response.json()
            return string_list
        else:
            print(f"Failed to fetch data from API. Status code: {response.status_code}")
            sys.exit(1)
    except Exception as e:
        print(f"An error occurred: {e}")
        sys.exit(1)

After having a list of possible posts, I need the script to decide which post to post next. For that, I am calculating which posts are nearest to the current day and month without taking the year into the calculation.

for entry in filtered_entries:
    if entry.published_parsed.tm_year == 0 or entry.published_parsed.tm_year == 1:
        skipped_entries.append(entry)
        continue  # Skip entries with invalid year
    temp = time.mktime(entry.published_parsed)
    published_time = datetime.fromtimestamp(temp)
    difference = abs(current_time.replace(year=published_time.year, tzinfo=None) - published_time)
    if min_difference is None or difference < min_difference:
        min_difference = difference
        closest_entry = entry

Then I select one of the closest entries randomly. I need to do this because if I would have taken many photos on one day there could be multiple items close to the current date.

Now we are ready for creating the post. Therefore, I am now preparing the caption which is included in the post.

def publish_entry(entry):
    caption = "More at https://lna-dev.net/en/gallery\n\n"

    for element in entry.tags:
        caption += '#' + element.term + " "

    mediaResponse = upload_media(entry)
    publish_post(caption, mediaResponse)

    published_entry(entry.title)

Now to the trickiest bit: The actual posting. This was especially interesting because at the time I created this script there was a lack of documentation and I needed to somehow figure this out on my own. I also didn’t find many examples searching the internet. The best I could do was look into the Mastodon documentation (because Pixelfeds API is similar) and figure it out on my own.

There are two important things here. First, you have to upload the media first before you can make the post which then simply contains the id of the media you uploaded beforehand. And second, you need to create a PAT (personal access token) and provide it via the bearer syntax to the API.

def upload_media(entry):
    media_url = f'{PIXELFED_INSTANCE_URL}/api/v1/media'
    headers = {
        'Authorization': f'Bearer {PAT}',
        'Accept': 'application/json'
    }
    files = {
        'file': download_image(entry.link)
    }
    data = {
        'description': re.search('alt="(.*?)"', entry.summary).group(1)
    }
    response = requests.post(media_url, headers=headers, files=files, data=data)
    if response.status_code == 200:
        return response.json()['id']
    else:
        print("Failed to upload media.")
        sys.exit(1)

def publish_post(caption, media_id):
    if caption.strip():
        post_url = f'{PIXELFED_INSTANCE_URL}/api/v1/statuses'
        headers = {
            'Authorization': f'Bearer {PAT}',
            'Accept': 'application/json'
        }
        data = {
            'status': caption,
            'media_ids[]': media_id
        }
        response = requests.post(post_url, headers=headers, data=data)
        if response.status_code == 200:
            print("Post published successfully!")
        else:
            print("Failed to publish post!")
            sys.exit(1)
    else:
        print("Caption cannot be empty.")
        sys.exit(1)

That done, I made a final API request to my personal API noting that I uploaded the image.

The schedule

This part was fairly easy because I was already using a Kubernetes cluster. I just needed to create a cronjob running each day and that’s it.

apiVersion: batch/v1
kind: CronJob
metadata:
  name: pixelfed-autoupload
spec:
  schedule: "0 16 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: pixelfed-autoupload
              image: lnadev/pixelfed-autoupload:{{ .Values.autoupload.pixelfed.version }}
              imagePullPolicy: Always
              resources:
                limits:
                  memory: "128Mi" 
                  cpu: "500m" # Don't use CPU limits in K8s but that is another topic...
              env:
                - name: PIXELFED_PAT
                  valueFrom:
                    secretKeyRef:
                      name: pixelfed
                      key: pat
                - name: API_KEY
                  valueFrom:
                    secretKeyRef:
                      name: personal-api-secret
                      key: apikey
          restartPolicy: Never
      backoffLimit: 0

One thing I had to learn here is the following: Setting the restartPolicy to never will not prevent the cronjob from retrying. You need to also set the backoffLimit to 0 to achieve the desired behavior. (This is because those two settings change different retry mechanisms you both want to disable.)

In this post, I want to explain what the Fediverse is and why you should join it. I talk very little about the technical stuff, but this post is intended to be understood by anyone.

Another post for the really technical topics is planned for the future.

Where does the name come from?

The name is a portmanteau of federation and universe. So the Fediverse is a federated universe.

This name does represent it pretty well. The Fediverse is decentralized web of social media platforms all connected to each other. Anyone can connect with anybody else, even if they are using completely different services. You can imagine it like email. Every user has an email address by a specific service, but they can write with anyone they want, not just with users of the same service.

For those who are familiar with the classic social networks: Imagine using Twitter and seeing Instagram or Facebook posts in your timeline, just like they would all be using Twitter. But that’s not all. There also could be YouTube videos or anything else. You decide. That is the beauty of the Fediverse.

Why is the Fediverse so important?

Decentralization

The old social media platforms are owned by companies. Not so is the Fediverse. First of all, there are many services in the Fediverse, so the whole thing cannot be owned. Just like the internet. Therefore, nobody can force users into something or exploit their market dominance, as the current big players do.

The creators of the Fediverse platform Peertube explained it in a straightforward way. Here is their explanation. (This video is by the way hosted on Peertube)

Free and Open Source

But even the producers of Fediverse software are very different. It mainly consists of FOSS (Free and Open Source Software), which means the software is genuinely free and independent developers can modify it and help to improve it. FOSS is incredibly important and I will cover its numerous advantages in a future post.

Because of this freedom, making money is more challenging. However, the user doesn’t get treated like trash, as the user contributes to the Fediverse through donations. Also, there are no ads because of that.

So, the software producers of the Fediverse are primarily volunteers or non-profit organizations. Both aim to make the internet a better place and not just want to make a bug.

Moreover, it’s not just the software producers who act fairly, the people who run the servers are mainly volunteers, organizations, or even states!

The force of the masses

Because you can freely choose your service in the Fediverse, no one gets excluded from society anymore. I find this to be a significant issue with classical social media platforms. I am not using any of these because of all the bad things they do. As a result, I sometimes feel a bit excluded in specific contexts.

This is extremely important when it comes to messengers. Not using the specific service that is popular in your region can have a significant impact. Personally, I stopped using WhatsApp for around a year. In Germany, where I’m from, it is used nearly without exception. A few people have Signal or Threema, but that’s about it. Not having WhatsApp did affect my day-to-day life significantly. While I thought that using other services might encourage a few people to switch, it did only to some extent. Not everyone made the transition and some friends or family members remained exclusively on WhatsApp. Beyond the challenge of communicating with those you know, like and love, there are difficulties in meeting new people. I’ve had experiences where some form negative opinions if you don’t use the service that is common. Moreover, the barrier of contacting someone is much higher if they need to install a new app and you cannot contact them because you don’t have the right messenger.

While a social media platform is not a messenger, the effects are quite similar: The people using the big service essentially force you to use it too!

Current culture in the Fediverse

The current culture in the Fediverse is a significant positive aspect. People in this community are exceptionally friendly compared to traditional social networks. Moreover, the Fediverse is highly inclusive. For instance, if you post an image without an alt text (allowing blind people to understand what the image is about), someone will certainly remind you to add it. This inclusivity is crucial to the community, emphasizing that everyone should have the opportunity to participate.

There’s also a good amount of instances for LGBTQ+ to create safe spaces for those people. I consistently see different instances with this objective.

Of course, this depends on which edge of the Fediverse you are at. But overall, I think there are many minorities in the Fediverse who are not as represented elsewhere. I recall a poll someone conducted with around 11,000 votes, asking how many queer people there are in the Fediverse. The result was 60% not queer and 40% queer. These are solid numbers. Of course, this result is biased in some way because of who the poll maker is and who reposts it. But with this number of votes, it definitely gives a good hint.

If someone wants to create artistic content that goes a bit beyond the guidelines of platforms like Instagram, it is acceptable in the Fediverse. You can choose an instance where the rules align with your preferences and create your content there. While most instances may require a content warning for specific posts, you are free to express yourself as you like.

Also, there is no need to upload regularly or avoid using specific words to please the algorithm. There is nothing like that here. There are no ads and therefore no advertisers which do not want you to say something “bad”. You can handle things how you and your instance want them to be.

Another immensely beneficial aspect here is that the moderator count per user is relatively high. This is because each instance is responsible for its moderation. As a result, every instance manages its part, leading to an overall high count of moderators. Moreover, if an instance becomes unmoderated, other servers will block them, ensuring a clean network.

But, after all, the Fediverse is currently a big home for people who are interested in technology. It is relatively new tech and because of that, there are a lot of nerds. Which is great!

Of course, these are not all groups of people, but I hope I could provide you with a bit of an overview of the kinds of people currently in the Fediverse. This may change as new people join us, but at the moment, this is how I perceive the Fediverse. Let’s hope we can maintain this diversity for the future.

Who is in the Fediverse?

For example, nearly all German institutions have an account on their own server of the state. Additionally, the public broadcasting providers ARD and ZDF have their own instances.

I just saw that the Netherlands also have a state owned Mastodon instance. I really like the idea of nations backing the network and hopefully the values, this network comes with.

Mozilla also created its own instance available to the public: Mozilla Social. However, there are another 26,000 servers waiting for you to explore them.

Currently there are around 10,000,000 users in the Fediverse with a total of about 1,200,000 of them being active in the last month. So you hopefully you find someone to connect with.

A good overview of instances and the biggest users can be found at FediDB.

Platforms

In this section, I want to showcase a few of the most important services of the Fediverse. But there are many more to be explored!

This image provides a quick overview of the different categories and services.

Mastodon

Mastodon is the biggest and also the most developed platform of the Fediverse. It is a microblogging service. The company behind it is a German non-profit company (gGmbH). It is comparable with Twitter and gained a lot of attraction during the catastrophic takeover of Elon Musk. At that time, there was a huge mass of people moving to Mastodon from Twitter.

After these events, the “freed” platform attracted even more extreme right-wing individuals. Additionally, many journalists face occasional blocks. If you truly seek a free platform, consider joining Mastodon: https://joinmastodon.org. (They also have a really fancy website: Check it out!)

Pixelfed

Instagram is a really big platform run by Meta, which is known for its extremely bad privacy and they also had a few scandals. For example, they helped manipulate elections. See Cambridge Analytica.

Pixelfed is the pardon from the Fediverse for Instagram. It is developed by a Canadian software engineer and the community.

In my opinion, it is not as widely developed as Mastodon. But it’s almost on a perfect level. It has many features, even some that classical Instagram does not have. But most importantly, it is part of the Fediverse and therefore, you could also consume the great photography available on Pixelfed from your Mastodon feed or whichever service you like the most.

And of course, Pixelfed is developed as Free and Open Source Software / FOSS!

You can join it at: https://pixelfed.org/

Lemmy

Lemmy is Reddit for the Fediverse and it is also FOSS. It seems to have a really active community. I personally did not try it out that much yet but it seems pretty good.

After all, the decision to use Lemmy is not that difficult if Reddit is the current choice. Reddit did screw up hard this year. Same as Twitter. They banned every third-party app and also made a couple of other bad decisions. On the image below, you see a Reddit event where the collective of Reddit users has written “Fuck spez!” which is the CEO of Reddit.

This is a great example that the community cannot do anything against the will of a platform like Reddit, Twitter, Instagram, TikTok… They are extremely powerful companies, maybe monopolies, exploiting their power of having all the users. Let’s break that! Let’s make a real change and go to the Fediverse!

If you are interested in Lemmy: https://join-lemmy.org/

Peertube

Peertube is an alternative to YouTube. Because video streaming is quite expensive and in a decentralized network, there are many smaller communities with less money. Peertube decided to use peer to peer. This means if you watch a video, you help someone else watching because your computer sends bits of the video to other persons. So the server does need less bandwidth and therefore, small communities are able to operate a video streaming platform. This approach comes with downsides, but after all, it makes something possible, which would be really hard to achieve in another way. A really free video platform.

In terms of content, this platform is still a bit niche. There are really good channels, especially in the privacy, tech and Linux community. But for more mainstream content, there is not that much to offer. This, of course, is not a problem of the platform but a problem of the creators who are not feeding the platform. I hope this will change in the future!

Because of the Fediverse, you can, of course, watch and subscribe to Peertube channels from Mastodon and other platforms.

Peertube is developed by the French non-profit association Framasoft as FOSS.

Here you can find more information: https://joinpeertube.org/

What about Threads (Meta)?

Now, bigger companies are starting to join the Fediverse. The biggest is Threads made by Meta.

Currently, Threads is implementing the required ActivityPub logic to join the network. You can already follow the CEO of Instagram and a few of the team. But it seems like the full connection will take a while to implement.

This topic is a controversy in the Fediverse. On one side stands that Meta is bringing a lot of users to the network, but on the other side, Meta is also well-known for incredibly bad privacy and being part of surveillance capitalism, hurting millions of users.

A few instances have even made the “Fedi-Pact” and therefore will block Meta on the server side when they are joining. This has an impact of about 7% of active users on the open side of the Fediverse. (Of course, only Meta will not see them. The rest of the network can still interact with them normally.)

If a server does not block a specific other server, the user still has the power to do that. Here, the founder of Mastodon explains his audience how it is done.

And, of course, Meta will not provide a platform that is nearly as free and open as the other ones I mentioned above. They are only trying to make money and hopefully are not destroying the Fediverse while doing that. The only good they do is that they bring a lot of users with them. That’s it. But this also may open the Fediverse to a lot of people, which would be great.

Meta joining is like a dance with the devil. But we may benefit from it.

Also worth mentioning

You are not stuck with your account on a server. Of course, you have the freedom to choose another one and take all your followers with you. No problem here. Free software doesn’t lock you in place.

Another thing getting weird in the old networks is the account verification. You now need to pay in both Instagram and Twitter to be verified, even if you are not a big creator or another person of interest. This is rather stupid and confusing. In the Fediverse, you do not need to pay anyone. You can just link yourself from another platform/website you own and you get a sign that this account/page is verified to be owned by you. A much better way of verification.

The technical stuff

I decided not to put the really technical stuff in this post. This would have made this blog post even longer than it is now. I have a bit of experience in creating servers for the Fediverse because of Fedodo. I want to share this experience in a future post and talk about the details of ActivityPub. This is the protocol powering most of the Fediverse.

Appreciations

Thanks to the amazing artists providing their work under Creative Commons licenses. They help me so much in illustrating this post. Links are available under each image. Go and check them out!

Also, thanks to you for reading this until the end. I hope I could give you a bit of an overview of the topic. And maybe I even convinced you to join us fighting for a better web. But don’t pressure yourself. Have fun ❤️

First of all, to get everyone on the same page, I need to explain what Fedodo is and why I started developing it.

With the rise of Mastodon, I became more and more interested in the ActivityPub protocol. I really like the idea of having a big decentralized platform that can compete with the walled gardens of big tech. The ActivityPub protocol seemed to be just right to achieve that.

Until now, everyone developed a platform for a specific use case:

• Mastodon as an alternative to Twitter.
• Pixelfed as an alternative to Instagram.
• Lemmy as an alternative to Reddit.
• And the list goes on…

I wanted to do this differently. I thought it would not be optimal to develop an ActivityPub server for each of these platforms. So my idea was to create an ActivityPub server which does not only implement the ActivityPub server to server protocol but also the ActivityPub client to server protocol. This client to server protocol was not really wide spread at this time. But it would allow anyone to use a frontend of their liking with the same server. Also every user now just needs one account. This is possible because Fedodo has a feature which allows multiple ActivityPub actors per user account.

As part of Fedodo, I wanted to develop not only the server but also a set of frontends. In detail, I developed a Mastodon-like frontend an was starting to develop a Pixelfed-like UI.

The development

I started developing Fedodo in December 2022 and worked on it extensively until August 2023. Dedicating around eight months to the project.

During this time, I successfully developed a functional server. While it might be beneficial to give it a bit more attention, write a few tests here and there, and fix a few things, overall, it is working great. In addition to that I had a basic Mastodon-like app kind of finished and made significant progress developing the Pixelfed alternative.

For me, this is significant achievement and I am also a bit pride. I even had the opportunity to participate in a podcast hosted by a significant German tech YouTuber and chat about ActivityPub. This was quite an honor for me. (To the episode)

What is the Problem?

During the development period, I dedicated approximately 380 hours solely to coding. In addition to this comes the time I thought about the project and did not have an editor open (which I did not track). This makes about one and a half hours per day just coding. Every day in this eight months. Only paid with the German minimum wage, this would make up a 4715€. Clearly, a significant amount of time and effort went into the Fedodo project.

The problem is I did this in addition to a 40 hours work week. So my total working hours per week were about 50 hours.

I really enjoy coding in my free time. It is a awesome hobby for me. The problem with big projects like Fedodo is that at some point you aren’t as hyped on it as in the beginning. And after some time, even a hobby project turns into work. And I think this is the significant problem.

If I am working on small projects I am hyped for it doesn’t feel like work. But Fedodo did after four to five months. And than the 50 hours per week effect you.

I would not recommend to anyone working on a project of this size. I think everything which you can completely finish in under half a year is fine. But if you have the feeling you do work in your freetime it is not worth it. So keep on doing smaller projects and enjoy the process of creating.

Another option would be joining a comparable large community, developing an open source project. There you could do small things and have a proportionally big impact with little effort.

How does the future of Fedodo look like?

This feeling of work and personal issues during this time led me to pausing the development of Fedodo and taking a break from coding in my freetime altogether.

Now, a few months later, I’m slowly beginning to have this urge again to create something. So, I think it was the right decision to take a step back.

However, I will not work on Fedodo this hard again. Given the project’s size, this likely means I won’t be able to bring it to completion. Sadly.

Fedodo is just to big for me

Privacy 🕵️

In my opinion privacy is the most important feature of a browser. A modern browser should protect you while you surfe the internet. Brave does have a lot of privacy features build in. And most important a lot more than Google Chrome which lacks a lot of privacy features.

Open Source

Open Source makes sure that what a company promises is what a company gives to its customers. Brave is Open Source on GitHub. This makes sure that everybody can control the software deployments. You can check it out right here.

Shields

The idea of Shields is to stop Online-Tracking. With this in mind Brave blocks following contents by default. The user can optionally disable the blocking for specific websites.

Shield Features

• Block third party ads
• Block third party trackers
• Resource Replacement
• CNAME uncloaking
• Block cross site cookies
• Ephemeral Storage
• Randomizing browser APIs
• Block Browser-language and font fingerprinting
• Block Phishing Sites

Build-in Tor

With Brave it is possible to open a new private window with Tor. It makes it really easy to use the Tor network without installing a new tool. It is also possible to open links with the .onion TLD.

Brave Search 🔍

Of course you can choose every Search-Engine available but Brave Search offers an alternative to Google Search. It is really new and of course at the moment not as good as Google Search but I think it is usable.

Cross-Platform 📲

Brave Browser is available for all major platforms:

1. Linux
2. Windows
3. Mac
4. Android
5. IOS

Sync

Brave offers the feature “Sync”. This feature allows the user to sync whatever the user wants with other devices. So you can have all your Bookmarks and co. on every device. It does not matter if you are on Mobile, Linux, Windows… it just works. In addition to this there is no account required for this feature. To Sync your stuff you just need to scan a QR-Code and select what you want to sync. (It is also possible to display and type in a view words)

Speed 🥇

Brave says it is three times faster than Chrome and uses less memory. In my experience that is true. Just try it out 😉

A new way of advertising 💲

Brave Rewards is a new way of provisioning ads. Brave blocks every ad by default. From a user perspective this is awesome of course. But as a creator point of view this sucks. They just don’t make money anymore. A lot of content is free and the creators get paid with the add revenue. This does not exist if all ads are blocked. So Brave developed a new way of provisioning ads. Brave can optionally serve ads to the user. BUT! this is completely privacy focused and does not track you. Also the user gets 70% of the money in form of the BAT Crypto-Currency, 15% gets the Website-Creator and the last 15% gets Brave itself. I think this is a pretty good deal for everybody. In my opinion the own data should be owned by yourself and this way of advertising supports that. In addition Brave offers the ability to give BAT back to the Creators. This can be done automatically or manually. So you can support the websites you use and like directly and specifically.

Crypto 🪙

Brave offers the ability to store your Cryptocurrency’s directly in your browser. They can be secured with a backup and it offers a lot of different Blockchains out of the box. But it is possible to add any additional networks.

Links 🔗

Brave
Wikipedia Brave Search
YouTube Techlore

In this post I want to join exurb1a on his statement about privacy and the importance of it in our day-to-day life. And much more important than this I want to showcase how to do it better. For this I will create posts about Privacy Tools and Privacy in general from time to time.

Prerequisites

This post is based on this video. I highly recommend watching it. It is a 10 out of 10 video about modern privacy. You can imagine the video to be based more on philosophical standpoint than on a technical one. He uses analogies but also explains a bit of the technical details. But the focus definitely lies on a philosophical point of view.

Why should I care about privacy?

If you say: “I like the amount of privacy I have right now” than you lay the first stones of a more privacy invading future. The way we do the things today shapes… no… determines the future!

If it is ok today than tomorrow it will be not. So in my opinion we have to change how we think about privacy.

The Erosion of Privacy Over Time

The digital landscape is ever-evolving, with technology penetrating deeper into our lives. What may seem like a tolerable invasion of privacy today could escalate into a more significant concern as new technologies and practices emerge. By proactively acknowledging this reality, we can actively participate in shaping the boundaries of our privacy. Especially empowering states or companies is a big issue. Even if your country currently is a well build democracy there can always be a change. As I am from Germany I am well aware of what countries with horrible ideas could do with those technologies at their fingertips.

Empowering People and Shaping How We Live Online

Privacy isn’t just about you or me it ripples through society. The choices we make today set the tone for tomorrow’s norms. The digital on social norms. When we stand up for privacy, we’re giving individuals the power to control their data and build a digital world that respects everyone’s rights in the online world and offline.

Let’s Be Mindful About Privacy

Changing our view on privacy is about making conscious choices. It’s looking at the way things are now, thinking about what could happen and actively finding ways to boost our online privacy. This isn’t just about shielding our own stuff, it’s about joining forces to make a digital world that’s more aware of privacy. Don’t let the powerful decide for us.

In simple terms, caring about privacy isn’t just a personal preference, it’s a shared responsibility that goes beyond just one person. It shapes where our digital journey is headed. Let’s get that, accept the responsibility, and team up for a future where privacy isn’t just talked about but truly looked after.

What should I do now?

I think the best you can do is staying well-informed to make good decisions. And this is not a thing you do once. It is a journey. There are many good sites which showcase good privacy respecting tools. If you are interested I always have a few interesting links at my Link-Page.

I also will showcase a couple of nice software I use and recommend. Stay tuned!

In this post I will teach you how to set up a blog like this with hugo and GitHub-Pages.

What you need

• GitHub-Account
• Markdown Knowledge
• Basic understanding of Pipelines (This time GitHub-Actions)
• Basic understanding of Git

Repository

All the actions below must be executed in a repository connected to GitHub.

Hugo

Install Hugo

Snap (Linux)

snap install hugo --channel=extended

Chocolatey (Windows)

choco install hugo-extended -confirm

Homebrew (Mac / Linux)

brew install hugo

If you need more information or installation options: Hugo - Docs - Installation

Create a new project

hugo new site <name of site> -f yml

Theme

Install a theme

In this tutorial we will use the PaperMod-Theme for Hugo.

1. Go to PaperMod-Theme and download the repo
2. Create a folder themes/PaperMod in your hugo project
3. Paste the files in the themes/PaperMod folder in your hugo project

Configure the theme

To configure the theme you must change the content of the config.yaml. Change it until it fits your needs. Further documentation about specific parameters can be found on the PaperMod-GitHub-Page.

Example YAML

baseURL: "https://examplesite.com/"
title: ExampleSite
paginate: 5
theme: PaperMod

enableRobotsTXT: true
buildDrafts: false
buildFuture: false
buildExpired: false

googleAnalytics: UA-123-45

minify:
  disableXML: true
  minifyOutput: true

params:
  env: production # to enable Google Analytics, opengraph, twitter-cards and schema.
  title: ExampleSite
  description: "ExampleSite description"
  keywords: [Blog, Portfolio, PaperMod]
  author: Me
  # author: ["Me", "You"] # multiple authors
  images: ["<link or path of image for opengraph, twitter-cards>"]
  DateFormat: "January 2, 2006"
  defaultTheme: auto # dark, light
  disableThemeToggle: false

  ShowReadingTime: true
  ShowShareButtons: true
  ShowPostNavLinks: true
  ShowBreadCrumbs: true
  ShowCodeCopyButtons: false
  ShowWordCount: true
  ShowRssButtonInSectionTermList: true
  UseHugoToc: true
  disableSpecial1stPost: false
  disableScrollToTop: false
  comments: false
  hidemeta: false
  hideSummary: false
  showtoc: false
  tocopen: false

  assets:
    # disableHLJS: true # to disable highlight.js
    # disableFingerprinting: true
    favicon: "<link / abs url>"
    favicon16x16: "<link / abs url>"
    favicon32x32: "<link / abs url>"
    apple_touch_icon: "<link / abs url>"
    safari_pinned_tab: "<link / abs url>"

  label:
    text: "Home"
    icon: /apple-touch-icon.png
    iconHeight: 35

  # profile-mode
  profileMode:
    enabled: false # needs to be explicitly set
    title: ExampleSite
    subtitle: "This is subtitle"
    imageUrl: "<img location>"
    imageWidth: 120
    imageHeight: 120
    imageTitle: my image
    buttons:
      - name: Posts
        url: posts
      - name: Tags
        url: tags

  # home-info mode
  homeInfoParams:
    Title: "Hi there \U0001F44B"
    Content: Welcome to my blog

  socialIcons:
    - name: twitter
      url: "https://twitter.com/"
    - name: stackoverflow
      url: "https://stackoverflow.com"
    - name: github
      url: "https://github.com/"

  analytics:
    google:
      SiteVerificationTag: "XYZabc"
    bing:
      SiteVerificationTag: "XYZabc"
    yandex:
      SiteVerificationTag: "XYZabc"

  cover:
    hidden: true # hide everywhere but not in structured data
    hiddenInList: true # hide on list pages and home
    hiddenInSingle: true # hide on single page

  editPost:
    URL: "https://github.com/<path_to_repo>/content"
    Text: "Suggest Changes" # edit text
    appendFilePath: true # to append file path to Edit link

  # for search
  # https://fusejs.io/api/options.html
  fuseOpts:
    isCaseSensitive: false
    shouldSort: true
    location: 0
    distance: 1000
    threshold: 0.4
    minMatchCharLength: 0
    keys: ["title", "permalink", "summary", "content"]
menu:
  main:
    - identifier: categories
      name: categories
      url: /categories/
      weight: 10
    - identifier: tags
      name: tags
      url: /tags/
      weight: 20
    - identifier: example
      name: example.org
      url: https://example.org
      weight: 30
# Read: https://github.com/adityatelange/hugo-PaperMod/wiki/FAQs#using-hugos-syntax-highlighter-chroma
pygmentsUseClasses: true
markup:
  highlight:
    noClasses: false
    # anchorLineNos: true
    # codeFences: true
    # guessSyntax: true
    # lineNos: true
    # style: monokai

Using a post template

/archetypes/

All files in the directory above can be used as templates for posts. The default.md file is the default file for generating new posts. All other files must be specified while creating a post.

Create a Post

I would always use the hugo commands to generate the files because it copies the standard configuration in the new file. I would generate the .md files always in the posts sub-folder (If you want to create a post 😉). Only files from this folder will be shown as posts.

hugo new <filePath>

Example

hugo new posts/BlogWithHugo.md

Build the page

The hugo command builds the project into a website. The files created are stored in the /public/ folder.

hugo

Debug the page

To view the page in the browser run the command below. There will be a link displayed which references the local hosted webpage.

hugo serve

Build and Deployment / Pipeline

Setup GitHub-Pages

1. Go into the settings of your repo
2. Select the GitHubPages tab
3. Set the source to GitHubActions

Add Pipeline YAML

Create following file.

.github/workflows/HugoBuildAndDeploy.yaml

Insert the following code into the file and adjust it to your needs. I described what I was doing per comments.

In this pipeline we will checkout the repo build it and after that deploy it to GitHub-Pages.

name: HugoBuildAndDeploy

on:
  workflow_dispatch: # To have the ability to run the workflow manually

  push:
    branches: [main]

env:
  NAME: LNA-DEV-Blog #TODO Change to your project name

jobs:
  HugoBuild:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repository
      - uses: actions/checkout@v3

      # Install Hugo
      - run: sudo snap install hugo

      # Build the hugo repository
      - run: hugo
        working-directory: ./${{ env.NAME }}/

      # Zip the Artifact for GitHubPages deployment
      - name: Archive artifact
        shell: bash
        if: runner.os != 'Windows'
        run: tar -cvf ${{ runner.temp }}/artifact.tar -C ./${{ env.NAME }}/public .

      # Create a build artifact
      - name: Upload a Build Artifact
        uses: actions/upload-artifact@v3.1.0
        with:
          name: github-pages
          path: ${{ runner.temp }}/artifact.tar

  DeployToGithubPages:
    needs: HugoBuild

    # Setup GitHubPages
    permissions:
      pages: write
      id-token: write

    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}

    # Deploy the artifact
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v1