Palmr: Selbstgehosteter Dateitransfer als WeTransfer-Alternative

Veröffentlicht 02.02.2026 Aktualisiert 02.02.2026

Von Darth Vaper

15 Minuten Lesezeit

WeTransfer kennt jeder: Schnell eine große Datei hochladen, Link verschicken, fertig. Aber wer einmal die Gratis-Version genutzt hat, kennt auch die Einschränkungen: 2 GB Limit, Links laufen nach 7 Tagen ab, und du weißt nie genau, wer unterwegs noch mitliest. Für gelegentliche Transfers mag das reichen, aber im professionellen Umfeld oder wenn dir Datensouveränität wichtig ist, wird es schnell unbefriedigend. Die Lösung? Eine selbstgehostete Alternative wie Palmr, die dir volle Kontrolle über deine Daten gibt und dabei trotzdem modern und benutzerfreundlich bleibt.

Was ist Palmr?

Palmr ist eine Open-Source-Lösung für selbstgehostetes File-Sharing, die sich als WeTransfer-Alternative positioniert. Das Projekt setzt auf einen modernen Tech-Stack mit Next.js im Frontend, Fastify als Backend und SQLite als Datenbank. Das Besondere: Palmr ist bewusst schlank gehalten und trotzdem vollgepackt mit Features, die du im produktiven Einsatz brauchst.

Die Architektur von Palmr: Next.js Frontend, Fastify Backend, SQLite und optionale S3-Storage

Der Tech-Stack wurde mit Bedacht gewählt: Next.js sorgt für eine reaktionsschnelle, moderne Web-UI mit Server-Side Rendering. Fastify bringt als Backend-Framework hohe Performance bei minimalem Overhead. SQLite als Datenbank macht die Installation trivial einfach, da keine separate Datenbank-Instanz nötig ist. Für größere Deployments lässt sich der Storage auf S3-kompatible Backends wie MinIO oder AWS S3 auslagern.

Das Projekt wird aktiv auf GitHub entwickelt und hat eine wachsende Community. Der Code ist sauber strukturiert und gut dokumentiert, was Anpassungen oder das Einbringen eigener Features vereinfacht.

Das Palmr-Repository findest du hier: github.com/kyantech/palmr

Features im Überblick

Palmr bringt eine beeindruckende Feature-Liste mit, die weit über simples File-Sharing hinausgeht:

Upload-Funktionen:

Drag & Drop Interface für intuitive Bedienung
Multi-File-Upload mit Progress-Anzeige
Configurable Dateigrößen-Limits
Automatische Kompression und Optimierung

Link-Verwaltung:

Passwortschutz für sensible Dateien
Custom-Links (Vanity URLs) wie share.example.com/projekt-alpha
Ablaufdatum mit automatischer Bereinigung
Download-Counter und Statistiken

Receive-Links: Eine der spannendsten Features sind Receive-Links. Statt selbst Dateien hochzuladen und zu teilen, kannst du einen Link erstellen, über den andere dir Dateien zusenden können. Perfekt für Situationen wie “Schick mir bitte deine Präsentation” oder “Lade hier die Fotos vom Event hoch”. Der Empfänger braucht keinen Account, du behältst trotzdem die Kontrolle über maximale Dateigröße und Ablauf.

Authentifizierung und Security:

OIDC/OAuth2 Integration (Authentik, Keycloak, Auth0)
Multi-User-Support mit Rollen
API-Keys für programmatischen Zugriff
Rate-Limiting und DDoS-Schutz

White-Labeling:

Eigenes Logo und Branding
Anpassbare Farbschemata
Konfigurierbare Seitentitel und Beschreibungen
Perfekt für professionelle Umgebungen oder Kunden-Deployments

Admin-Features:

Dashboard mit Upload-Statistiken
User-Management
Storage-Monitoring
Expired-Links-Cleanup

Palmr unterstützt S3-kompatible Storage-Backends, was es ermöglicht, die eigentliche Datenspeicherung auf skalierbaren Object-Storage auszulagern.

Installation mit Docker

Die einfachste Installation läuft über Docker Compose. Hier ist eine funktionierende Konfiguration für den Start:

        
      
services:
  palmr:
    image: kyantech/palmr:latest
    container_name: palmr
    ports:
      - 3000:3000
    volumes:
      - palmr_data:/app/data
      - palmr_uploads:/app/uploads
    environment:
      - DATABASE_URL=file:/app/data/palmr.db
      - UPLOAD_DIR=/app/uploads
      - MAX_FILE_SIZE=10737418240  # 10 GB
      - APP_URL=https://share.example.com
      - TZ=Europe/Berlin
      - LINK_LENGTH=8
      - ALLOW_REGISTRATION=false
    restart: unless-stopped
    networks:
      - palmr

volumes:
  palmr_data:
    driver: local
  palmr_uploads:
    driver: local

networks:
  palmr:
    driver: bridge

Die wichtigsten Environment-Variablen auf einen Blick:

Variable	Beschreibung	Default
`DATABASE_URL`	SQLite-Datenbankpfad	`file:/app/data/palmr.db`
`UPLOAD_DIR`	Verzeichnis für hochgeladene Dateien	`/app/uploads`
`MAX_FILE_SIZE`	Max. Dateigröße in Bytes	`10737418240` (10 GB)
`APP_URL`	Externe URL deiner Instanz	-
`LINK_LENGTH`	Länge generierter Share-Links	`8`
`ALLOW_REGISTRATION`	Öffentliche Registrierung erlauben	`true`

Nach dem Start erreichst du Palmr unter http://localhost:3000. Für den produktiven Betrieb solltest du einen Reverse-Proxy mit SSL davor setzen.

        
      
# Container starten
docker compose up -d

# Logs anzeigen
docker compose logs -f palmr

# Status prüfen
docker compose ps

Setze ALLOW_REGISTRATION=false in Produktionsumgebungen und erstelle Accounts manuell über das Admin-Interface.

Erste Schritte

Nach dem ersten Start führt dich Palmr durch einen Setup-Wizard. Hier erstellst du den initialen Admin-Account. Wichtig: Dieser erste User bekommt automatisch Admin-Rechte, alle später registrierten User (falls ALLOW_REGISTRATION=true) bekommen Standard-Rechte.

Admin-Dashboard aufrufen: Nach dem Login findest du oben rechts das User-Menü. Als Admin siehst du hier einen zusätzlichen Menüpunkt “Administration”. Das Dashboard zeigt dir:

Gesamtzahl der Uploads
Aktuell genutzter Storage
Anzahl aktiver Links
User-Statistiken

Grundeinstellungen: Im Settings-Bereich kannst du die wichtigsten Parameter deiner Instanz konfigurieren:

Site Name: Wird im Browser-Tab und Header angezeigt
Logo: Upload deines eigenen Logos (empfohlen: SVG oder PNG mit transparentem Hintergrund)
Max. File Size: Überschreibt das Environment-Variable lokal
Default Link Expiry: Standard-Ablaufdatum für neue Links (z.B. 7 Tage)

Ersten Share-Link erstellen: Die Haupt-Upload-Seite ist selbsterklärend:

Datei per Drag & Drop in den Upload-Bereich ziehen
Oder “Durchsuchen” klicken und Datei auswählen
Optional: Passwort setzen
Optional: Custom-Link definieren (statt zufälligem String)
Optional: Ablaufdatum anpassen
Upload starten

Nach dem Upload bekommst du sofort einen teilbaren Link. Du siehst auch eine Übersicht über alle deine aktiven Links, kannst diese nachträglich bearbeiten oder löschen.

Receive-Link testen: Receive-Links sind das Killer-Feature für Zusammenarbeit:

Im Dashboard “Create Receive Link” klicken
Titel und Beschreibung eingeben (z.B. “Fotos vom Teamevent”)
Maximale Dateigröße und Anzahl festlegen
Link teilen

Der Empfänger braucht keinen Account, kann aber über den Link Dateien hochladen. Du bekommst eine Notification (falls konfiguriert) und siehst alle eingegangenen Uploads im Dashboard.

Receive-Links sind ideal für Situationen, in denen du Dateien von externen Partnern oder Kunden einsammeln musst, ohne diesen Zugang zu deinem System zu geben.

Konfiguration im Detail

S3 Storage Backend

Für größere Installationen oder wenn du ohnehin S3-Storage nutzt, kannst du Palmr so konfigurieren, dass alle Uploads direkt in einem S3-Bucket landen. Das reduziert die Last auf dem Palmr-Server und ermöglicht praktisch unbegrenzten Storage.

Beispiel mit MinIO (selbstgehostete S3-Alternative):

        
      
services:
  palmr:
    image: kyantech/palmr:latest
    environment:
      - S3_ENABLED=true
      - S3_ENDPOINT=http://minio:9000
      - S3_BUCKET=palmr-uploads
      - S3_ACCESS_KEY=minioadmin
      - S3_SECRET_KEY=minioadmin
      - S3_REGION=us-east-1
      - S3_FORCE_PATH_STYLE=true  # Wichtig für MinIO

Für AWS S3:

        
      
environment:
  - S3_ENABLED=true
  - S3_ENDPOINT=https://s3.eu-central-1.amazonaws.com
  - S3_BUCKET=meine-palmr-uploads
  - S3_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE
  - S3_SECRET_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
  - S3_REGION=eu-central-1

Mit S3-Storage kannst du Palmr praktisch unbegrenzt skalieren. Die SQLite-Datenbank speichert nur Metadaten, die eigentlichen Dateien liegen im Object-Storage.

OIDC Authentication

Statt lokaler User-Accounts kannst du Palmr an deinen bestehenden Identity Provider anbinden. Hier ein Beispiel mit Authentik:

        
      
environment:
  # OIDC Basis-Konfiguration
  - OIDC_ENABLED=true
  - OIDC_CLIENT_ID=palmr
  - OIDC_CLIENT_SECRET=dein-geheimer-client-secret
  - OIDC_ISSUER=https://auth.example.com/application/o/palmr/

  # Endpoints (falls nicht auto-discovery)
  - OIDC_AUTH_URL=https://auth.example.com/application/o/authorize/
  - OIDC_TOKEN_URL=https://auth.example.com/application/o/token/
  - OIDC_USERINFO_URL=https://auth.example.com/application/o/userinfo/

  # Mapping
  - OIDC_USERNAME_CLAIM=preferred_username
  - OIDC_EMAIL_CLAIM=email
  - OIDC_NAME_CLAIM=name

Mit OIDC aktiviert verschwindet das lokale Login-Formular und wird durch einen “Login with SSO”-Button ersetzt. User werden automatisch angelegt, wenn sie sich das erste Mal anmelden.

Reverse Proxy Setup

Fuer den produktiven Betrieb brauchst du SSL und einen sauberen Hostnamen. Hier die gaengigen Varianten:

Variante 1: Nginx Proxy Manager (NPM)

Die komfortabelste Loesung mit grafischer Oberflaeche:

Neuen Proxy Host erstellen
Domain: share.example.com
Forward Hostname: palmr (Container-Name oder IP)
Forward Port: 3000
SSL: Let’s Encrypt aktivieren
Websockets Support: Aktivieren
Custom Nginx Configuration (Advanced-Tab):

        
      
client_max_body_size 10G;
proxy_connect_timeout 600s;
proxy_send_timeout 600s;
proxy_read_timeout 600s;

Das client_max_body_size-Limit ist entscheidend. Standardmaessig liegt das Nginx-Limit bei nur 1 MB - jeder Upload ueber dieser Groesse schlaegt fehl. Setze den Wert mindestens so hoch wie MAX_FILE_SIZE.

Variante 2: Nginx (manuell)

Falls du Nginx direkt konfigurierst:

        
      
server {
    listen 443 ssl http2;
    server_name share.example.com;

    ssl_certificate /etc/ssl/certs/share.example.com.crt;
    ssl_certificate_key /etc/ssl/private/share.example.com.key;

    client_max_body_size 10G;  # Muss >= MAX_FILE_SIZE sein

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;

        # Timeouts fuer grosse Uploads
        proxy_connect_timeout 600s;
        proxy_send_timeout 600s;
        proxy_read_timeout 600s;
    }
}

Variante 3: Traefik

Fuer Traefik-Setups via Docker-Labels:

        
      
services:
  palmr:
    image: kyantech/palmr:latest
    # ... restliche Config ...
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.palmr.rule=Host(`share.example.com`)"
      - "traefik.http.routers.palmr.entrypoints=websecure"
      - "traefik.http.routers.palmr.tls.certresolver=letsencrypt"
      - "traefik.http.services.palmr.loadbalancer.server.port=3000"

Upload-Limits und Performance

Die wichtigsten Performance-Parameter:

        
      
environment:
  # File-Limits
  - MAX_FILE_SIZE=10737418240        # 10 GB
  - MAX_FILES_PER_UPLOAD=10
  - MAX_RECEIVE_LINK_SIZE=21474836480  # 20 GB

  # Rate-Limiting
  - RATE_LIMIT_ENABLED=true
  - RATE_LIMIT_WINDOW=900000         # 15 Minuten
  - RATE_LIMIT_MAX_REQUESTS=100

  # Link-Generierung
  - LINK_LENGTH=8                    # Länge der Share-IDs
  - DEFAULT_EXPIRY_DAYS=7

  # Cleanup
  - AUTO_CLEANUP_ENABLED=true
  - CLEANUP_INTERVAL=3600000         # Jede Stunde

Das automatische Cleanup löscht abgelaufene Links und die zugehörigen Dateien. Alternativ kannst du einen Cronjob auf dem Host einrichten:

        
      
#!/bin/bash
# Cleanup-Script für Palmr
docker exec palmr node /app/scripts/cleanup.js

# Täglich um 3 Uhr morgens
0 3 * * * /opt/palmr/cleanup.sh >> /var/log/palmr-cleanup.log 2>&1

Vergleich: Palmr vs. Alternativen

Wie schlägt sich Palmr im Vergleich zu WeTransfer und anderen Self-Hosted-Lösungen?

Feature	Palmr	WeTransfer Free	WeTransfer Pro	Pingvin Share	Send (Mozilla)
Max. Dateigröße	Konfigurierbar	2 GB	200 GB	Unbegrenzt	2.5 GB
Link-Ablauf	Konfigurierbar	7 Tage	30 Tage	Konfigurierbar	1-7 Tage
Passwortschutz	Ja	Nein	Ja	Ja	Ja
Custom-Links	Ja	Nein	Ja	Nein	Nein
Receive-Links	Ja	Nein	Ja	Nein	Nein
OIDC/OAuth2	Ja	Nein	Nein	Nein	Nein
Self-Hosted	Ja	Nein	Nein	Ja	Ja (eingestellt)
White-Labeling	Ja	Nein	Ja	Begrenzt	Nein
S3 Storage	Ja	-	-	Nein	Nein
API	Ja	Ja	Ja	Ja	Nein
Admin-Dashboard	Ja	Nein	Ja	Ja	Nein
Kosten	Kostenlos	Kostenlos	12€/Monat	Kostenlos	Kostenlos
Aktive Entwicklung	Ja	Ja	Ja	Ja	Nein (archiviert)

Wann macht welche Lösung Sinn?

WeTransfer Free: Für gelegentliche Transfers ohne Anforderungen an Datenschutz oder Kontrolle. Perfekt für Quick-Shares im privaten Bereich.

WeTransfer Pro: Wenn du die Features brauchst, aber kein eigenes Hosting aufsetzen willst. Die 200 GB-Grenze und 30 Tage Aufbewahrung sind großzügig.

Palmr: Ideal, wenn du Datensouveränität brauchst, OIDC-Integration willst oder White-Labeling benötigst. Perfekt für Unternehmen oder professionelle Homelabs.

Pingvin Share: Simpler und minimalistischer als Palmr, dafür ohne S3-Support und OIDC. Gute Wahl für rein private Nutzung ohne komplexe Anforderungen.

Send (Mozilla): War mal eine gute Option, wurde aber 2020 eingestellt. Es gibt Community-Forks, aber ohne aktive Entwicklung durch Mozilla riskant für produktiven Einsatz.

Palmr punktet vor allem durch die Kombination aus modernem Stack, Enterprise-Features (OIDC, S3, White-Labeling) und aktivem Development. Für Homelabs mit Anspruch die beste Wahl.

Tipps für den produktiven Betrieb

Backups

Da Palmr SQLite verwendet, sind Backups erfreulich simpel:

        
      
#!/bin/bash
# Backup-Script für Palmr

BACKUP_DIR="/backup/palmr"
DATE=$(date +%Y%m%d_%H%M%S)

# Container-Name
CONTAINER="palmr"

# Datenbank sichern (mit konsistentem Checkpoint)
docker exec $CONTAINER sqlite3 /app/data/palmr.db ".backup /app/data/backup.db"
docker cp $CONTAINER:/app/data/backup.db $BACKUP_DIR/palmr_db_$DATE.db
docker exec $CONTAINER rm /app/data/backup.db

# Uploads sichern (falls nicht auf S3)
docker run --rm \
  --volumes-from $CONTAINER \
  -v $BACKUP_DIR:/backup \
  alpine tar czf /backup/palmr_uploads_$DATE.tar.gz /app/uploads

# Alte Backups löschen (älter als 30 Tage)
find $BACKUP_DIR -name "palmr_*" -mtime +30 -delete

echo "Backup completed: $DATE"

Wenn du S3-Storage nutzt, kannst du auf das Upload-Backup verzichten und nur die Datenbank sichern. Der S3-Bucket sollte über Lifecycle-Policies und Versioning abgesichert sein.

Monitoring

Einfaches Uptime-Monitoring mit curl:

        
      
#!/bin/bash
URL="https://share.example.com/api/health"
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" $URL)

if [ $RESPONSE -ne 200 ]; then
    echo "Palmr is down! HTTP $RESPONSE"
    # Notification senden (z.B. via Gotify, ntfy.sh)
    curl -X POST https://gotify.example.com/message \
      -H "X-Gotify-Key: YOUR_TOKEN" \
      -F "title=Palmr Down" \
      -F "message=HTTP Status: $RESPONSE"
fi

Als Cronjob alle 5 Minuten:

*/5 * * * * /opt/palmr/monitor.sh

Für professionelles Monitoring kannst du Prometheus-Metriken exportieren (wenn du einen eigenen Exporter baust) oder auf bestehende Container-Monitoring-Lösungen wie cAdvisor setzen.

Storage-Management

Bei intensiver Nutzung kann der Storage schnell wachsen. Palmrs Auto-Cleanup hilft, aber manchmal willst du manuell aufräumen:

        
      
# Alle abgelaufenen Links finden und löschen
docker exec palmr node -e "
const db = require('/app/db');
const now = Date.now();
db.prepare('DELETE FROM links WHERE expires_at < ?').run(now);
console.log('Expired links cleaned up');
"

# Storage-Nutzung analysieren
docker exec palmr du -sh /app/uploads
docker exec palmr find /app/uploads -type f -printf '%s %p\n' | sort -nr | head -20

Update-Strategie

Palmr-Updates sind unkompliziert:

        
      
# Aktuelles Image pullen
docker compose pull

# Container neu starten (Downtime: wenige Sekunden)
docker compose up -d

# Logs prüfen
docker compose logs -f palmr

Vor Major-Updates solltest du ein Backup machen und die Release Notes checken. Die Entwickler sind aber bisher sehr vorsichtig mit Breaking Changes.

Teste Updates immer erst in einer Staging-Umgebung, bevor du sie produktiv ausrollst. Ein zweiter Docker-Container auf einem Testhost ist schnell aufgesetzt.

Security Best Practices

ALLOW_REGISTRATION deaktivieren: In Production sollten User-Accounts nur über das Admin-Interface erstellt werden.
Rate-Limiting aktivieren: Schützt vor Missbrauch und DDoS-Versuchen.
OIDC/OAuth2 nutzen: Statt lokaler Passwörter lieber gegen deinen zentralen IDP authentifizieren.
Regelmäßige Updates: Sicherheitspatches zeitnah einspielen.
Reverse Proxy: Nie direkt Palmr exponieren, immer über Nginx/Traefik mit SSL.
Link-Ablauffristen: Default-Expiry sollte konservativ sein (z.B. 7 Tage). User können bei Bedarf verlängern.
Max. File Size: Setze realistische Limits. 10 GB sind für die meisten Use-Cases mehr als genug.

Erweiterte Use Cases

White-Labeling für Kunden

Palmr eignet sich hervorragend, um File-Sharing als Service anzubieten:

        
      
environment:
  - SITE_NAME=MeineFirma File Share
  - LOGO_URL=/assets/custom-logo.svg
  - PRIMARY_COLOR=#0066cc
  - SECONDARY_COLOR=#004080
  - FOOTER_TEXT=© 2026 MeineFirma GmbH
  - PRIVACY_URL=https://example.com/privacy
  - TERMS_URL=https://example.com/terms

Das Logo legst du als Volume-Mount ein:

        
volumes:
  - ./custom-assets:/app/public/assets:ro

API-Integration

Palmr bietet eine REST-API für programmatischen Zugriff. Beispiel in Python:

        
      
import requests

API_URL = "https://share.example.com/api"
API_KEY = "dein-api-key"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Datei hochladen
files = {"file": open("document.pdf", "rb")}
response = requests.post(
    f"{API_URL}/upload",
    headers=headers,
    files=files,
    data={"password": "geheim123", "expiry": "7d"}
)

share_link = response.json()["link"]
print(f"Share-Link: {share_link}")

# Link-Statistiken abrufen
link_id = share_link.split("/")[-1]
stats = requests.get(f"{API_URL}/links/{link_id}/stats", headers=headers)
print(f"Downloads: {stats.json()['downloads']}")

Multi-Tenancy

Obwohl Palmr kein natives Multi-Tenancy bietet, kannst du mehrere Instanzen hinter einem Reverse-Proxy betreiben:

        
      
# Kunde A
server {
    server_name share-kundea.example.com;
    location / {
        proxy_pass http://palmr-kundea:3000;
    }
}

# Kunde B
server {
    server_name share-kundeb.example.com;
    location / {
        proxy_pass http://palmr-kundeb:3000;
    }
}

Jede Instanz bekommt eigene Volumes und Konfiguration. Mit Docker Compose Labels kannst du das elegant orchestrieren.

Troubleshooting

Uploads schlagen fehl

Symptom: Uploads brechen ab oder Fehlermeldung “File too large”

Lösung:

MAX_FILE_SIZE in Environment-Variablen prüfen
client_max_body_size in Nginx anpassen
Timeouts erhöhen (proxy_read_timeout)
Freien Speicherplatz auf Host prüfen

Links funktionieren nicht

Symptom: Share-Links führen zu 404 oder zeigen falsche URL

Lösung:

APP_URL in Environment-Variablen muss korrekt gesetzt sein
Reverse-Proxy muss X-Forwarded-Proto und X-Forwarded-Host setzen
Keine Trailing-Slashes in APP_URL verwenden

Performance-Probleme bei großen Dateien

Symptom: Browser friert ein, langsame Uploads

Lösung:

Chunk-Upload-Größe anpassen (in Palmr-Config)
S3-Storage statt lokalem Filesystem nutzen
Upload-Progress-Updates reduzieren
Reverse-Proxy Buffering deaktivieren (proxy_buffering off;)

Datenbank-Locks

Symptom: Fehler “database is locked” im Log

Lösung:

Bei hoher Last: SQLite durch PostgreSQL ersetzen (experimentell)
Temp-Dateien auf schnellerem Storage (z.B. SSD statt HDD)
Concurrent-Writes limitieren (Rate-Limiting)

SQLite ist für die meisten Use-Cases völlig ausreichend. Bei mehr als 100 gleichzeitigen Usern solltest du über PostgreSQL nachdenken.

Roadmap und Community

Palmr wird aktiv weiterentwickelt. Auf der GitHub-Roadmap stehen unter anderem:

WebDAV-Support: Direktes Mounten als Netzlaufwerk
E2E-Verschlüsselung: Client-seitige Verschlüsselung vor Upload
Mobile Apps: Native iOS/Android-Apps
Collaborative Features: Kommentare und Annotations
Advanced Analytics: Detaillierte Download-Statistiken und Heatmaps
PostgreSQL-Support: Als Alternative zu SQLite für High-Load-Szenarien

Die Community ist auf GitHub aktiv, Issues werden schnell beantwortet und Pull Requests sind willkommen. Es gibt auch einen Discord-Server für direkten Austausch mit den Entwicklern.

Wenn du einen Bug findest oder ein Feature vermisst, schau in die GitHub Issues. Die Entwickler sind offen für Feedback und nehmen sinnvolle Vorschläge gerne in die Roadmap auf.

Fazit

Palmr ist eine ausgereifte, moderne Self-Hosted-Lösung für File-Sharing, die WeTransfer in fast allen Punkten schlägt. Die Kombination aus Next.js-Frontend und Fastify-Backend sorgt für eine schnelle, reaktive User-Experience. Features wie Receive-Links, OIDC-Integration und S3-Support machen Palmr auch für professionelle Umgebungen interessant.

Besonders beeindruckend ist die Einfachheit der Installation: Ein Docker Compose File, minimale Konfiguration, und schon läuft die Instanz. Gleichzeitig bietet Palmr genug Flexibilität für komplexe Setups mit White-Labeling, Custom-Storage und externem Identity-Management.

Für wen macht Palmr Sinn?

Homelab-Betreiber, die WeTransfer-Funktionalität selbst hosten wollen
Unternehmen mit Datenschutz-Anforderungen
Agenturen, die Kunden gebrandete File-Sharing-Lösungen anbieten
Power-User, die volle Kontrolle über ihre Daten haben möchten

Die aktive Entwicklung und wachsende Community sind weitere Pluspunkte. Palmr ist kein Eintagsfliegen-Projekt, sondern wird kontinuierlich verbessert und erweitert.

Wenn du also eine selbstgehostete WeTransfer-Alternative suchst, probiere Palmr aus. Die Einrichtung dauert keine 10 Minuten, und die Feature-Liste lässt kaum Wünsche offen.

Ressourcen

Palmr GitHub: github.com/kyantech/palmr
Palmr Dokumentation: docs.palmr.io
Docker Hub: hub.docker.com/r/kyantech/palmr
Community Discord: discord.gg/palmr
Alternative: Pingvin Share: github.com/stonith404/pingvin-share
Alternative: Firefox Send (Fork): github.com/timvisee/send
S3-kompatible Backends:
- MinIO: min.io
- Wasabi: wasabi.com
- Backblaze B2: backblaze.com/b2

Happy Sharing!

Homelab, Tools

palmr file-transfer file-sharing wetransfer self-hosted docker homelab nextjs web-ui

Dieser Eintrag ist vom Autor unter CC BY 4.0 lizensiert.

Was ist Palmr?

Features im Überblick

Installation mit Docker

Erste Schritte

Konfiguration im Detail

S3 Storage Backend

OIDC Authentication

Reverse Proxy Setup

Variante 1: Nginx Proxy Manager (NPM)

Variante 2: Nginx (manuell)

Variante 3: Traefik

Upload-Limits und Performance

Vergleich: Palmr vs. Alternativen

Tipps für den produktiven Betrieb

Backups

Monitoring

Storage-Management

Update-Strategie

Security Best Practices

Erweiterte Use Cases

White-Labeling für Kunden

API-Integration

Multi-Tenancy

Troubleshooting

Uploads schlagen fehl

Links funktionieren nicht

Performance-Probleme bei großen Dateien

Datenbank-Locks

Roadmap und Community

Fazit

Ressourcen

Beliebte Tags