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.

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 ❤️