---
title: "Forgejo vs Gitea (2026): Unterschiede & Actions Runner"
description: "Forgejo v17 vs Gitea v28 im Vergleich: Governance, GPL vs MIT, LTS-Support, Wechselgründe und getestetes Docker Compose mit Forgejo Runner v13."
date: 2026-11-20
categories: ["self-hosting"]
tags: ["forgejo","gitea","docker"]
---

Im ersten Jahr nach dem Forgejo-Fork Ende 2022 waren beide Projekte fast deckungsgleich. Ein einfacher Image-Tag-Wechsel reichte. Das ist vorbei. Seit dem Hard Fork 2024 haben sich Lizenz, Versionsnummern, LTS-Zusagen und Upgrade-Pfade sauber getrennt.

In der selfh.st-Community-Umfrage 2026 hat Forgejo Gitea erstmals überholt. Trotzdem hängt die richtige Wahl an deinen konkreten Anforderungen an eine Git-Forge und nicht an Foren-Stimmung. Hier ist der sachliche Vergleich zwischen Forgejo v17 und Gitea v28 Ende 2026, gefolgt von einem getesteten Docker-Compose-Setup mit Forgejo 17.0.2 und dem nativen Forgejo Runner (`v13.2.2`).

## Forgejo vs Gitea Ende 2026

Beide sind schlanke Go-Binaries mit Pull Requests, Issues, Paket-/Container-Registry und eingebauter Actions-CI. Beide liegen im Leerlauf um 100 MB RAM (`codeberg.org/forgejo/forgejo:17` brauchte bei mir **104,5 MiB** auf Docker 29.2) und damit etwa 20x unter GitLab. Die echten Unterschiede:

| Bereich | Forgejo | Gitea |
|---|---|---|
| Aktuelles Release (Nov. 2026) | **v17.0.2** (18. Nov. 2026) | **v28.3.0** (`1.`-Präfix ab 28.0 gestrichen) |
| LTS-Zweig | **Ja** (v15.0.12 bis 15. Juli 2027) | Keine dokumentierte LTS-Linie |
| Lizenz | **GPL-3.0-or-later** (ab v9.0) | **MIT** |
| Governance | Community-geführt unter dem gemeinnützigen Codeberg e.V. | CommitGo, Inc. (kommerziell) + 6er-TOC (3 Firma, 3 gewählt) |
| Bezahlte Enterprise-Edition | Keine; alle Features offen | Bezahlte Enterprise-Tarife & Gitea Cloud |
| CI / Actions | Forgejo Actions + `forgejo-runner` v13 (hohe Kompatibilität, Fokus auf Unabhängigkeit) | Gitea Actions + `act_runner` (zielt eng auf GitHub-Actions-Parität) |
| ActivityPub-Föderation | Aktiv in Entwicklung (experimentell, föderierte Stars laufen) | Nicht dokumentiert |
| Direkter Wechsel von Gitea | Nur bis Gitea 1.22; neuere Versionen per API-Migration | k. A. |

## Warum viele Self-Hoster zu Forgejo wechseln

Drei handfeste Gründe treiben den Wechsel, und nur einer davon ist Governance:

1. **Planbare LTS-Releases.** Forgejo bringt jedes Quartal ein stabiles Release und macht das erste Release jedes Jahres zu einem 15-Monats-LTS (aktuell v15.0.x bis Juli 2027). Für Homelabs und kleine Teams, die Sicherheits-Updates ohne vierteljährliche Breaking Changes wollen, ist das Gold wert.
2. **Kein Paywall-Drift.** Als Gitea Ltd (heute CommitGo, Inc.) 2022 Marken und kommerziellen Betrieb übernahm, wuchs die Sorge vor abwandernden Enterprise-Features. Mit GPL-3.0-or-later unter einem gemeinnützigen deutschen Verein ist dieses Risiko vom Tisch.
3. **Schnelleres Security-Hardening.** Forgejo zieht Sicherheits-Defaults zügig an (v17.0.2 verschärfte gerade SSH-Key-Matching, Scoped-Token-Feeds und PR-Secret-Zugriffe).

Wann bleibt **Gitea** sinnvoller? Wenn deine Rechtsabteilung GPL-3.0 ausschließt, ihr einen kommerziellen SLA-Vertrag braucht oder extrem enge GitHub-Actions-Parität über `act_runner` verlangt.

**Lässt sich Gitea noch direkt durch das Forgejo-Image ersetzen?**

Nur bis Gitea 1.22. Da die Datenbank-Migrationen nach dem Hard Fork auseinanderliefen, scheitert Forgejo 17 an einer Gitea-28-Datenbank. Für aktuelle Gitea-Instanzen startest du ein frisches Forgejo und importierst Repos samt Issues und PRs über Forgejos eingebauten Gitea-API-Migrator.

## Forgejo 17 + PostgreSQL + Forgejo Runner in Docker

Falls du lieber eine getrennte CI mit kompakter YAML-Syntax willst, bleibt unser [Forgejo + Woodpecker CI Guide](/forgejo-woodpecker-ci-cicd/) (auf Englisch) eine gute Alternative. Für integrierte GitHub-ähnliche `.forgejo/workflows/`-Pipelines ist hier der getestete Stack mit `codeberg.org/forgejo/forgejo:17` (17.0.2) und `data.forgejo.org/forgejo/runner:13` (v13.2.2).

Eine Stolperfalle aus meinem Test: **Auf `data.forgejo.org` gibt es kein `:latest`-Tag** für den Runner (`runner:latest` liefert `not found`). Pinne immer die Major-Version (`:13`).

### Schritt 1: Runner-Verzeichnis vorbereiten

Der Runner läuft ohne Root-Rechte (`uid 1000`). Erstelle das Verzeichnis, erzeuge die Standard-Konfig und setze die Rechte:

```bash
mkdir -p forgejo-stack/runner-data/.cache
cd forgejo-stack

docker run --rm data.forgejo.org/forgejo/runner:13 \
  forgejo-runner generate-config > runner-data/config.yml

sudo chown -R 1000:1000 runner-data
```

### Schritt 2: `compose.yaml` anlegen

Dieser Stack startet Forgejo 17, PostgreSQL 19 (mit dem seit PG 18 nötigen `/var/lib/postgresql`-Mount, siehe [PostgreSQL 19 Guide](/de/postgresql-19-neuheiten/)), einen isolierten Docker-in-Docker-Daemon für Job-Container und den Forgejo Runner. So bleiben CI-Jobs vom Host-Docker-Socket getrennt.

```yaml
services:
  db:
    image: postgres:19-alpine
    container_name: forgejo-db
    restart: unless-stopped
    environment:
      POSTGRES_USER: forgejo
      POSTGRES_PASSWORD: starkes-passwort-einsetzen
      POSTGRES_DB: forgejo
    volumes:
      - pgdata:/var/lib/postgresql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U forgejo"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - forgejo_net

  forgejo:
    image: codeberg.org/forgejo/forgejo:17
    container_name: forgejo
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    environment:
      USER_UID: 1000
      USER_GID: 1000
      FORGEJO__database__DB_TYPE: postgres
      FORGEJO__database__HOST: db:5432
      FORGEJO__database__NAME: forgejo
      FORGEJO__database__USER: forgejo
      FORGEJO__database__PASSWD: starkes-passwort-einsetzen
      FORGEJO__actions__ENABLED: "true"
      FORGEJO__actions__DEFAULT_ACTIONS_URL: "https://data.forgejo.org"
    volumes:
      - ./forgejo-data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "127.0.0.1:3000:3000"
      - "2222:22"
    networks:
      - forgejo_net

  docker-dind:
    image: docker:dind
    container_name: forgejo-dind
    restart: unless-stopped
    privileged: true
    command: ["dockerd", "-H", "tcp://0.0.0.0:2375", "--tls=false"]
    networks:
      - runner_net

  runner:
    image: data.forgejo.org/forgejo/runner:13
    container_name: forgejo-runner
    restart: unless-stopped
    depends_on:
      - docker-dind
      - forgejo
    user: "1000:1000"
    environment:
      DOCKER_HOST: tcp://docker-dind:2375
    volumes:
      - ./runner-data:/data
    command: ["forgejo-runner", "daemon", "--config", "/data/config.yml"]
    networks:
      - forgejo_net
      - runner_net

volumes:
  pgdata:

networks:
  forgejo_net:
  runner_net:
```

Starte zuerst Datenbank und Forgejo:

```bash
docker compose up -d db forgejo
```

Öffne `http://127.0.0.1:3000`, schließe den kurzen Installer ab und lege deinen Admin-Nutzer an.

### Schritt 3: Runner registrieren und starten

Hole dir unter **Website-Administration -> Actions -> Runners -> Neuen Runner erstellen** das Token und registriere den Runner einmalig:

```bash
docker compose run --rm runner forgejo-runner register \
  --no-interactive \
  --instance http://forgejo:3000 \
  --token DEIN_TOKEN_HIER \
  --name homelab-runner \
  --labels "docker:docker://node:22-bookworm,ubuntu-latest:docker://catthehacker/ubuntu:act-latest"
```

Danach DinD und Runner starten:

```bash
docker compose up -d docker-dind runner
docker compose logs -f runner
```

Der Runner meldet sich jetzt als **Idle** in Forgejo.

### Schritt 4: Workflow testen

Lege `.forgejo/workflows/ci.yml` in einem Repo an:

```yaml
name: Build check
on: [push, pull_request]

jobs:
  test:
    runs-on: docker
    steps:
      - uses: actions/checkout@v4
      - name: Check environment
        run: |
          node -v
          ls -la
```

Dank `FORGEJO__actions__DEFAULT_ACTIONS_URL=https://data.forgejo.org` zieht `actions/checkout@v4` direkt von Forgejos gepflegtem Mirror ohne GitHub-Abhängigkeit.

## Praxistipps für den Betrieb

- Für maximale Ruhe das LTS-Tag pinnen. Nutze codeberg.org/forgejo/forgejo:15 statt :17, wenn du reine Sicherheits-Updates ohne vierteljährliche Änderungen bevorzugst.

- Passwörter auslagern. Pack das Postgres-Passwort in eine .env-Datei oder [Docker Compose Secrets](/docker-compose-secrets/) (auf Englisch).

- Sowohl Postgres als auch ./forgejo-data sichern. Git-Repos liegen im Dateisystem, Issues und PRs in Postgres — automatisierbar z. B. mit [Zerobyte und Restic](/de/zerobyte-restic-gui/).

- HTTPS per Reverse Proxy vorschalten. Terminiere TLS über Caddy oder Traefik und passe ROOT_URL an deine Domain an.

## Fazit

Wer 2026 einen neuen Self-Hosted-Git-Server fürs Homelab oder ein kleines Team aufsetzt, fährt mit **Forgejo** besser: gleicher ~100-MB-Footprint wie Gitea, echter LTS-Zweig, GPL-3.0-Absicherung und in zehn Minuten laufende Actions-CI. **Gitea** bleibt erste Wahl, wenn MIT-Lizenz oder kommerzieller Support durch CommitGo Pflicht sind.

## Häufige Fragen (FAQ)

**Laufen bestehende GitHub-Actions-Workflows in Forgejo Actions?**

Die meisten einfachen Workflows (Checkout, Node/Python/Go-Tests, Docker-Builds) laufen mit minimalen oder keinen Änderungen. Komplexere Workflows mit GitHub-spezifischen APIs oder reinen github.com-Actions brauchen teils Anpassungen oder volle URLs bei `uses:`.

**Warum schlägt docker compose mit runner:latest not found fehl?**

Forgejo Runner veröffentlicht bewusst kein `:latest`-Tag auf `data.forgejo.org`, damit automatische Pulls keine Breaking Changes überspringen. Pinne immer eine Hauptversion wie `data.forgejo.org/forgejo/runner:13`.

**Reicht SQLite statt PostgreSQL für Forgejo?**

Ja, für Einzelentwickler mit ein paar Dutzend Repositories läuft SQLite sauber und spart einen Container. Sobald mehrere Personen parallel pushen oder Actions-Logs wachsen, verhindert PostgreSQL Lock-Fehler.