Open Source Sustainment And The Future Of Gitea

Welcome back to Self-Hosted Tech! If you’ve been running a homelab for any amount of time, you probably have a stack of old mini PCs, a repurposed enterprise server, or maybe a cluster of Raspberry Pis humming away in your closet. But hardware is only half the equation. The true magic of the homelab comes from the open-source software we run on that hardware.

Today, we need to talk about a critical topic that affects every single one of us who relies on free and open-source software (FOSS): Open Source Sustainment. And we’re going to explore this through the lens of a recent, highly debated event in the self-hosting community—the formation of Gitea Ltd. and the subsequent birth of the Forgejo fork.

What does the future hold for Gitea? How do we keep open-source projects alive without burning out the developers? And most importantly, how does this affect the software running on your homelab hardware? Let’s dive in.

The Gitea Dilemma: A Brief History

If you write code, manage infrastructure, or tinker with local AI models, you need a way to track versions. You need Git. While GitHub is the undisputed king of the cloud, many homelabbers prefer to keep their code local. Enter Gitea.

Gitea is a lightweight, incredibly fast, self-hosted Git service. Written in Go, it compiles into a single binary and can run on practically anything—from a beefy AMD EPYC server down to a $35 Raspberry Pi. It was originally forked from another project called Gogs back in 2016 because the Gogs community felt development was stagnating. Gitea was meant to be the community-driven, fast-moving alternative.

For years, it was exactly that.

However, as Gitea grew in popularity, so did the burden on its core maintainers. Managing an open-source project with thousands of users, handling security vulnerabilities, and pushing out new features became a massive unpaid job. To solve this, in late 2022, the core Gitea team announced the creation of Gitea Ltd., a for-profit company (specifically, a UK Community Interest Company, or B-corp).

The goal was to secure funding, hire full-time developers, and ensure the project’s long-term survival. The software would remain open-source under the MIT license, but the governance and trademark would be held by the company.

The Community Backlash

The announcement did not go over well with a large portion of the community. Many felt blindsided. The ethos of Gitea was deeply rooted in community ownership, and the sudden shift to a corporate structure—even a well-intentioned B-corp—felt like a betrayal to some contributors.

This led to the creation of Forgejo, a “soft fork” of Gitea. Forgejo is governed by a non-profit organization (Codeberg e.V.) and aims to be a fully community-driven, democratic project.

We aren’t here to pick sides or declare a winner. Both projects want the best for the software. But this situation highlights a massive, systemic problem in the tech world: Open Source Sustainment.

What is Open Source Sustainment?

Let’s be real for a second. Open source is “free” as in speech, but it still costs money and time to build.

When you download a Docker container, spin up a VM, or clone a repo, you are benefiting from hundreds—if not thousands—of hours of unpaid labor. Open source sustainment is the ongoing challenge of figuring out how to pay the bills, compensate developers for their time, and keep the servers running, all while maintaining the community spirit that makes FOSS so great in the first place.

In the homelab and local AI space, we are entirely dependent on sustainment. Think about the tools you use daily: Proxmox, Docker, Home Assistant, Ollama, and Gitea. If the maintainers of those projects burn out and walk away, we are left with abandoned software that slowly becomes incompatible with modern hardware and operating systems.

The Funding Spectrum

Projects try to sustain themselves in a few different ways:

Donations and Sponsorships: Relying on the goodwill of users and corporate sponsors (e.g., Open Collective, GitHub Sponsors). It’s noble, but highly unpredictable.
Open Core / Freemium: The core software is free, but advanced features, support, or hosted versions cost money (e.g., GitLab, Couchbase).
Non-Profit Foundations: A trusted entity holds the trademark and manages funds transparently (e.g., The Linux Foundation, Apache Software Foundation, and now Forgejo).
For-Profit Companies: A company owns the project, hoping to monetize it through enterprise support or hosted services while keeping the base code open (e.g., Gitea Ltd., Redis Labs).

There is no perfect answer. Gitea chose the corporate route to guarantee developer salaries. Forgejo chose the non-profit route to guarantee community control.

The Future of Gitea

So, where does Gitea go from here?

Despite the drama, the future of Gitea is actually quite bright. The creation of Gitea Ltd. did succeed in its primary goal: it brought on paid developers who have been pushing out impressive updates.

One of the most exciting additions to Gitea recently is Gitea Actions. This is a built-in CI/CD (Continuous Integration/Continuous Deployment) system that is highly compatible with GitHub Actions. For homelabbers, this is a game-changer. You can now run your automated testing, build your local AI Docker images, and deploy your infrastructure code directly from your self-hosted Gitea instance without needing to set up a separate Jenkins or Drone CI server.

As for Forgejo, it is tracking closely with Gitea, occasionally pulling in Gitea’s updates while adding its own community-driven features. The competition might actually be healthy. It forces Gitea Ltd. to remain responsive to the community, and it forces Forgejo to prove that a non-profit model can sustain rapid development.

Practical Walkthrough: Self-Hosting Gitea on Your Homelab Hardware

Enough theory—let’s get our hands dirty. One of the best ways to support open source sustainment is to actually use the software. Let’s deploy Gitea on your homelab hardware.

Because Gitea is written in Go, it is incredibly lightweight. You don’t need a massive server. An old Intel NUC, a Raspberry Pi 4, or a tiny virtual machine on your Proxmox node with 1GB of RAM and 10GB of storage is more than enough to run a personal Git server for you and your friends.

We are going to use Docker and Docker Compose for this setup, as it’s the standard for modern homelabs.

Prerequisites

A Linux machine (bare metal or VM) with Docker and Docker Compose installed.
SSH access to your machine.
A basic understanding of the terminal.

Step 1: Create the Docker Compose File

First, SSH into your homelab server. Create a directory for Gitea and navigate into it:

1
2
mkdir -p ~/docker/gitea
cd ~/docker/gitea

Now, create a docker-compose.yml file using your favorite text editor (like nano or vim):

1
nano docker-compose.yml

Paste the following configuration into the file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
      # Change these to your domain or IP
      - GITEA__server__DOMAIN=git.yourlocalip.com
      - GITEA__server__ROOT_URL=http://git.yourlocalip.com:3000/
    volumes:
      - ./gitea-data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000" # Web UI
      - "222:22"    # SSH for Git
    networks:
      - gitea

Note: Make sure to change git.yourlocalip.com to your actual server’s IP address or local domain name.

Step 2: Launch the Container

Save the file and exit your text editor. Now, simply bring the container up:

1
docker-compose up -d

Docker will pull the latest Gitea image, create the network, and start the container in detached mode.

Step 3: Initial Configuration

Open up your web browser and navigate to http://YOUR_SERVER_IP:3000.

You will be greeted by the Gitea setup screen. For a simple homelab setup, you can leave most of the database settings as default (it will use SQLite, which is perfect for single-node setups and saves you from having to deploy a separate PostgreSQL container).

Database Type: SQLite3
Server Domain: Your IP or domain
Application URL: http://YOUR_SERVER_IP:3000/

Scroll down to the Administrator Account Settings section. It’s highly recommended to create your admin account right now so you don’t get locked out. Fill in an admin username and password, then click Install Gitea.

The page will refresh, and within a few seconds, you’ll be looking at your very own self-hosted Git server!

Step 4: Create a Repository and Push Code

Now that Gitea is running on your hardware, let’s use it.

Log in with your new admin account.
Click the + icon in the top right corner and select New Repository.
Name it homelab-configs and click Create Repository.

On your local computer, open a terminal and configure your Git identity if you haven’t already:

1
2
git config --global user.name "Your Name"
git config --global user.email "[email protected]"

Create a local folder, initialize it, and push it to your new server:

1
2
3
4
5
6
7
8
9
mkdir homelab-configs
cd homelab-configs
echo "# My Homelab Configs" >> README.md
git init
git add README.md
git commit -m "Initial commit"
git branch -M main
git remote add origin http://YOUR_SERVER_IP:3000/yourusername/homelab-configs.git
git push -u origin main

Congratulations! You are now self-hosting your code. You’ve taken a load off the public cloud servers and put it onto your own hardware.

How You Can Help Sustain Open Source

Deploying software is fun, but we have to remember the humans behind the code. If you want to ensure that tools like Gitea, Forgejo, and your other homelab favorites stick around for the long haul, here are a few practical ways to help:

Financial Support: If you have a few extra dollars a month, set up a recurring donation via GitHub Sponsors, Open Collective, or Patreon. Recurring donations allow maintainers to budget.
Contribute Code: If you know Go, Python, or JavaScript, look at the “good first issue” tags on GitHub or Codeberg.
Write Documentation: Bad documentation is a massive drain on developers who have to answer the same questions over and over. If you figured out a complex setup, write a wiki article or a blog post.
Be Kind: Open source maintainers deal with a lot of entitlement. Simply being polite, providing detailed bug reports, and saying “thank you” goes a surprisingly long way in preventing burnout.

Summary

The split between Gitea and Forgejo is a perfect case study in the complexities of open-source sustainment. It proves that “free” software isn’t truly free—it requires time, energy, and money to maintain. While Gitea has moved toward a corporate model to fund development, Forgejo stands as a community-driven alternative. Both are excellent pieces of software that run beautifully on homelab hardware.

By understanding the challenges developers face, we can be better users and contributors to the FOSS ecosystem.

Call to Action: If you haven’t already, fire up a spare VM or an old mini PC and deploy Gitea using the walkthrough above. Take control of your code! Once you have it running, head over to the Gitea or Forgejo donation pages and buy the maintainers a coffee.

Have you deployed Gitea or Forgejo in your homelab? Are you using Gitea Actions for CI/CD yet? Drop a comment below or join our community Discord to share your setup. Keep tinkering, keep self-hosting, and we’ll see you in the next one!

Open Source Sustainment And The Future Of Gitea#

The Gitea Dilemma: A Brief History#

The Community Backlash#

What is Open Source Sustainment?#

The Funding Spectrum#

The Future of Gitea#

Practical Walkthrough: Self-Hosting Gitea on Your Homelab Hardware#

Prerequisites#

Step 1: Create the Docker Compose File#

Step 2: Launch the Container#

Step 3: Initial Configuration#

Step 4: Create a Repository and Push Code#

How You Can Help Sustain Open Source#

Summary#