Funkwhale vs Ampache: Which Music Server Wins?

Quick Verdict

Ampache is the better choice for most self-hosters who just want to stream their music library. It has a simpler setup, lighter resource footprint, mature Subsonic API support for third-party apps, and decades of battle-tested library management. Funkwhale is the pick if you care about federated social music sharing via ActivityPub — sharing tracks across instances, following other users, and building a decentralized music community. For pure “I have a music collection and want to stream it,” Ampache wins.

Overview

Funkwhale is a modern, federated audio platform built with Django and Vue.js. It supports music libraries, podcasts, and channels, and federates with other Funkwhale instances and the broader Fediverse through ActivityPub. Think of it as a self-hosted SoundCloud that can talk to Mastodon. Development started in 2017 and the project is community-governed.

Ampache is a veteran music streaming server that has been around since 2001. It is a PHP-based web application with a built-in MySQL database, offering extensive library management, multi-user support, smart playlists, and broad API compatibility including its own Ampache API and the Subsonic API. It focuses on doing one thing well: organizing and streaming your music collection.

Feature Comparison

Feature	Funkwhale	Ampache
Primary focus	Federated social music platform	Music library management and streaming
ActivityPub federation	Yes — share music across instances	No
Podcast support	Yes — built-in channels and podcasts	Yes — podcast catalog support
Subsonic API	Yes (partial compatibility)	Yes (full compatibility)
Mobile apps	Subsonic-compatible apps (DSub, Ultrasonic)	Subsonic-compatible apps plus native Ampache apps
Multi-user support	Yes	Yes — with granular access control
Smart playlists	Basic	Advanced — rule-based smart playlists
Video support	No	Yes — video catalog and streaming
Web UI	Modern Vue.js SPA	Functional PHP-rendered interface
Music upload	Yes — users can upload directly	Yes — admin-managed catalogs
Scrobbling	Last.fm, ListenBrainz	Last.fm, Libre.fm
Transcoding	Yes (server-side)	Yes (on-the-fly, configurable bitrate)
Remote catalogs	No	Yes — Subsonic, WebDAV, Seafile remotes
License	AGPL-3.0	AGPL-3.0
Language/Stack	Python (Django), Vue.js, PostgreSQL, Redis, Celery	PHP, MySQL/MariaDB
Docker complexity	Multi-container (6+ services)	Single all-in-one container

Docker Compose Setup

Funkwhale

Funkwhale runs as a multi-service stack: PostgreSQL, Redis, Celery workers, the API, a Nginx frontend, and optionally Typesense for search. This is significantly more complex than Ampache.

Create a .env file first:

# Required — your public domain (cannot change after first deploy)
FUNKWHALE_HOSTNAME=music.example.com
FUNKWHALE_PROTOCOL=https

# Generate with: openssl rand -base64 45
DJANGO_SECRET_KEY=change-me-generate-a-real-key

# Funkwhale version
FUNKWHALE_VERSION=1.4.0

# Bind address for the frontend
FUNKWHALE_API_IP=0.0.0.0
FUNKWHALE_API_PORT=5000

# Number of web workers (default 4, adjust to CPU count)
FUNKWHALE_WEB_WORKERS=4

# PostgreSQL (used by the postgres container)
POSTGRES_DB=funkwhale
POSTGRES_USER=funkwhale
POSTGRES_PASSWORD=change-me-strong-password

# Funkwhale database connection (matches above)
DATABASE_URL=postgresql://funkwhale:change-me-strong-password@postgres:5432/funkwhale
CACHE_URL=redis://redis:6379/0

# Where your music lives on the host
MUSIC_DIRECTORY_PATH=/srv/funkwhale/data/music
MEDIA_ROOT=/srv/funkwhale/data/media

# Nginx max upload size
NGINX_MAX_BODY_SIZE=100M

Create the docker-compose.yml:

services:
  postgres:
    image: postgres:15-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - funkwhale-db:/var/lib/postgresql/data
    networks:
      - funkwhale

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - funkwhale-redis:/data
    networks:
      - funkwhale

  celeryworker:
    image: funkwhale/api:${FUNKWHALE_VERSION}
    restart: unless-stopped
    env_file: .env
    command: celery -A funkwhale_api.taskapp worker -l INFO --concurrency=2
    depends_on:
      - postgres
      - redis
    volumes:
      - ${MUSIC_DIRECTORY_PATH}:/music:ro
      - funkwhale-media:/srv/funkwhale/data/media
    networks:
      - funkwhale

  celerybeat:
    image: funkwhale/api:${FUNKWHALE_VERSION}
    restart: unless-stopped
    env_file: .env
    command: celery -A funkwhale_api.taskapp beat -l INFO
    depends_on:
      - postgres
      - redis
    networks:
      - funkwhale

  api:
    image: funkwhale/api:${FUNKWHALE_VERSION}
    restart: unless-stopped
    env_file: .env
    depends_on:
      - postgres
      - redis
    volumes:
      - ${MUSIC_DIRECTORY_PATH}:/music:ro
      - funkwhale-media:/srv/funkwhale/data/media
      - funkwhale-static:/srv/funkwhale/data/static
    networks:
      - funkwhale

  front:
    image: funkwhale/front:${FUNKWHALE_VERSION}
    restart: unless-stopped
    depends_on:
      - api
    environment:
      FUNKWHALE_API_HOST: api
      FUNKWHALE_API_PORT: 5000
      NGINX_MAX_BODY_SIZE: ${NGINX_MAX_BODY_SIZE}
    ports:
      - "${FUNKWHALE_API_IP}:${FUNKWHALE_API_PORT}:80"
    volumes:
      - funkwhale-media:/srv/funkwhale/data/media:ro
      - funkwhale-static:/srv/funkwhale/data/static:ro
    networks:
      - funkwhale

volumes:
  funkwhale-db:
  funkwhale-redis:
  funkwhale-media:
  funkwhale-static:

networks:
  funkwhale:

Start the stack and initialize the database:

docker compose up -d
docker compose run --rm api funkwhale-manage migrate
docker compose run --rm api funkwhale-manage fw users create --superuser

After the superuser prompt, access the web UI at http://your-server-ip:5000.

Ampache

Ampache ships as a single all-in-one container with Apache, PHP, and MySQL bundled together. Much simpler to deploy.

Create a .env file:

# Database credentials
MYSQL_USER=ampache
MYSQL_PASS=change-me-strong-password

# Automated install variables (skip web wizard)
DB_NAME=ampache
DB_HOST=localhost
DB_USER=ampache
DB_PASSWORD=change-me-strong-password
DB_PORT=3306

# Admin account
AMPACHE_ADMIN_USER=admin
AMPACHE_ADMIN_PASSWORD=change-me-admin-password
[email protected]

Create the docker-compose.yml:

services:
  ampache:
    image: ampache/ampache:7.9.2
    container_name: ampache
    restart: unless-stopped
    ports:
      - "8080:80"
    env_file: .env
    volumes:
      # Music library — point to your collection
      - /path/to/your/music:/media:ro
      # Persistent data
      - ampache-config:/var/www/config
      - ampache-log:/var/log/ampache
      - ampache-mysql:/var/lib/mysql
    environment:
      - DISABLE_INOTIFYWAIT_CLEAN=0

volumes:
  ampache-config:
  ampache-log:
  ampache-mysql:

Start Ampache:

docker compose up -d

Access the web UI at http://your-server-ip:8080. If you set the automated install variables, the database and admin account are created automatically. Otherwise, the web installer walks you through setup.

After installation, go to Admin > Catalogs > Add Catalog and point it at /media to scan your music library.

Installation Complexity

Ampache wins here by a wide margin. A single container, one port, four volume mounts, and you are streaming music. The all-in-one image bundles everything — no external database or cache to manage.

Funkwhale requires six containers minimum: PostgreSQL, Redis, two Celery processes, the API server, and the Nginx frontend. You need to run database migrations manually, generate a Django secret key, and configure a reverse proxy. The .env file has significantly more variables to get right. Expect 15-30 minutes for a first-time Funkwhale setup versus 5 minutes for Ampache.

Performance and Resource Usage

Resource	Funkwhale	Ampache
RAM (idle)	~500-800 MB (all containers combined)	~150-250 MB
RAM (active streaming)	~800-1200 MB	~250-400 MB
CPU (idle)	Low-moderate (Celery workers polling)	Low
Disk (application)	~2 GB (images + database)	~500 MB (application + database)
Disk (music)	Depends on library	Depends on library

Ampache is dramatically lighter. The single PHP process with MySQL uses a fraction of what Funkwhale’s Python/Django stack with PostgreSQL, Redis, and Celery consumes. On a Raspberry Pi 4 or a low-end VPS, Ampache will run comfortably. Funkwhale needs at least 2 GB of RAM to avoid swapping.

Community and Support

Ampache has been around since 2001 — over two decades of development. The codebase is mature and stable. The community is smaller than it once was but still active on GitHub. Documentation is thorough if somewhat dated in style. The project has survived multiple eras of web development, which speaks to its resilience.

Funkwhale has a younger but passionate community centered around the Fediverse. Development is community-governed with a formal governance structure. Documentation is modern and well-organized. However, development pace has slowed at times, and the project has gone through governance transitions. The 2.0 release has been in alpha for an extended period.

Metric	Funkwhale	Ampache
GitHub stars	~1.7K	~3.6K
First release	2017	2001
Latest stable	1.4.0	7.9.2 (Mar 2026)
Update frequency	Moderate	Regular
Documentation	Modern, well-structured	Comprehensive, functional

Use Cases

Choose Funkwhale If…

• You want to share music across a federated network — follow users on other instances, discover music socially
• You plan to host podcasts alongside music on the same platform
• You are building a community music platform, not just a personal jukebox
• ActivityPub integration matters to you — your music instance participates in the Fediverse
• You want users to upload their own music directly through the web UI

Choose Ampache If…

• You have a large personal music library and want a reliable way to stream it anywhere
• You rely on Subsonic-compatible mobile apps like DSub, Ultrasonic, or play:Sub
• You want the lightest possible resource footprint — a Raspberry Pi or cheap VPS will handle it
• You need advanced library management: smart playlists, multiple catalogs, granular user permissions
• You also want to stream video from the same server
• You prefer a simple, single-container Docker deployment
• You need remote catalog support (Subsonic, WebDAV, Seafile backends)

Final Verdict

For the typical self-hoster who owns a music collection and wants to stream it from their server, Ampache is the clear winner. It is simpler to set up, lighter on resources, has better Subsonic API compatibility for mobile apps, offers more advanced library management features, and has 25 years of proven stability. One container, five minutes, done.

Funkwhale carves out a strong niche for anyone who cares about the social side of music — federation, sharing, community features. If your goal is to build a mini SoundCloud that talks to the Fediverse, Funkwhale is purpose-built for that. But if you just want to replace Spotify with your own music library, Ampache does the job with less overhead.

Pick Ampache for library management. Pick Funkwhale for social music sharing. When in doubt, start with Ampache — you can always add Funkwhale later if you want the federation features.

Related

• Best Self-Hosted Music Streaming
• How to Self-Host Funkwhale
• How to Self-Host Ampache
• How to Self-Host Navidrome
• How to Self-Host Jellyfin
• Docker Compose Basics
• Reverse Proxy Setup