Friendica vs Hubzilla: Federated Social Platforms Compared
Quick Verdict
Friendica and Hubzilla share a developer lineage — Mike Macgirvin created Friendica, then built Hubzilla as its spiritual successor with a more ambitious architecture. Friendica focuses on being a Facebook-like social network that federates everywhere. Hubzilla adds nomadic identity (your account can move between servers seamlessly) and a built-in CMS/wiki/cloud storage platform. The practical choice is Friendica because it has better ActivityPub compatibility, a larger user base, and simpler deployment — Hubzilla’s extra features come at the cost of complexity most users don’t need.
Updated February 2026: Verified with latest Docker images and configurations.
Overview
Friendica started in 2010 as one of the earliest federated social networks. It speaks ActivityPub, Diaspora protocol, and OStatus — connecting to Mastodon, Pixelfed, Lemmy, Diaspora pods, and other Fediverse platforms. The interface resembles Facebook with a timeline, friend requests, groups, events, and photo albums. It’s maintained by an active community with regular releases.
Hubzilla launched in 2015, built by Friendica’s original creator. Its signature feature is nomadic identity via the Zot6 protocol: your identity isn’t tied to a single server. If your Hubzilla instance goes down, you can seamlessly resume on another instance with all your connections, posts, and permissions intact. Beyond social networking, Hubzilla includes a wiki, CMS (web pages), CalDAV calendars, file storage (WebDAV), and a granular permissions system.
Feature Comparison
| Feature | Friendica 2026.01 | Hubzilla (latest) |
|---|---|---|
| Primary model | Facebook-like social network | Social network + CMS + wiki + cloud |
| Federation protocols | ActivityPub, Diaspora, OStatus | Zot6, ActivityPub, Diaspora |
| ActivityPub compatibility | Strong (primary protocol) | Functional but secondary to Zot6 |
| Nomadic identity | No | Yes (clone account across servers) |
| Friend requests | Yes (mutual/one-way) | Yes (with fine-grained permissions) |
| Groups / forums | Yes (community forums) | Yes (channels with role-based access) |
| Events / calendar | Yes | Yes (with CalDAV integration) |
| Photo albums | Yes | Yes |
| File storage | No | Yes (WebDAV, cloud-like file manager) |
| Wiki | No | Yes (built-in) |
| CMS / web pages | No | Yes (create public web pages) |
| Permission system | Basic (public, friends, private) | Granular (per-item, per-contact, roles) |
| Addons / plugins | 80+ official addons | 70+ plugins |
| Docker image | Official: friendica:2026.01-apache | Community: ghcr.io/saiwal/hubzilla-docker |
| Database | MariaDB / MySQL | MariaDB / MySQL |
| License | AGPL-3.0 | MIT |
Installation Complexity
Friendica has an official Docker image and a straightforward multi-container setup:
services:
db:
image: mariadb:11.4
environment:
MYSQL_ROOT_PASSWORD: CHANGE_ME_ROOT_PASSWORD
MYSQL_USER: friendica
MYSQL_PASSWORD: CHANGE_ME_DB_PASSWORD
MYSQL_DATABASE: friendica
volumes:
- db_data:/var/lib/mysql
restart: unless-stopped
redis:
image: redis:7.4-alpine
volumes:
- redis_data:/data
restart: unless-stopped
app:
image: friendica:2026.01-apache
environment:
MYSQL_HOST: db
MYSQL_USER: friendica
MYSQL_PASSWORD: CHANGE_ME_DB_PASSWORD
MYSQL_DATABASE: friendica
FRIENDICA_URL: https://social.example.com
FRIENDICA_ADMIN_MAIL: [email protected]
volumes:
- app_data:/var/www/html
ports:
- "8080:80"
depends_on:
- db
- redis
restart: unless-stopped
cron:
image: friendica:2026.01-apache
command: cron.sh
environment:
MYSQL_HOST: db
MYSQL_USER: friendica
MYSQL_PASSWORD: CHANGE_ME_DB_PASSWORD
MYSQL_DATABASE: friendica
volumes:
- app_data:/var/www/html
depends_on:
- db
- redis
restart: unless-stopped
volumes:
db_data:
redis_data:
app_data:The official image handles initial database setup, admin account creation, and cron job scheduling. Set FRIENDICA_URL to your public URL and configure a reverse proxy with SSL.
Hubzilla has no official Docker image. The most maintained community image requires more manual configuration:
services:
db:
image: mariadb:11.4
environment:
MYSQL_ROOT_PASSWORD: CHANGE_ME_ROOT_PASSWORD
MYSQL_USER: hubzilla
MYSQL_PASSWORD: CHANGE_ME_DB_PASSWORD
MYSQL_DATABASE: hubzilla
volumes:
- db_data:/var/lib/mysql
restart: unless-stopped
app:
# Community image — no versioned Docker tags published
image: ghcr.io/saiwal/hubzilla-docker:latest
environment:
DB_HOST: db
DB_PORT: "3306"
DB_TYPE: "1"
DB_NAME: hubzilla
DB_USER: hubzilla
DB_PASS: CHANGE_ME_DB_PASSWORD
HUBZILLA_DOMAIN: hub.example.com
HUBZILLA_ADMIN: [email protected]
volumes:
- app_data:/var/www/html
ports:
- "8080:80"
depends_on:
- db
restart: unless-stopped
volumes:
db_data:
app_data:Critical: Hubzilla requires HTTPS from the very first request. Setting up HTTP first and switching later permanently breaks federation and discovery. Configure your reverse proxy with a valid SSL certificate before starting the Hubzilla container. The community Docker image also lacks versioned tags — you’re running whatever latest points to, which complicates reproducible deployments.
Performance and Resource Usage
| Resource | Friendica 2026.01 | Hubzilla |
|---|---|---|
| RAM (idle) | 300-500 MB | 300-500 MB |
| RAM (active, 20 users) | 500 MB - 1 GB | 500 MB - 1 GB |
| CPU | Low-medium | Low-medium |
| Disk (application) | 200 MB + uploads | 200 MB + uploads + files |
| Containers | 4 (app, cron, MariaDB, Redis) | 2 (app, MariaDB) |
| Background processing | Dedicated cron container | Built-in cron (Apache module) |
Resource usage is comparable. Both are PHP applications backed by MariaDB. Friendica adds Redis for caching (optional but recommended), while Hubzilla’s additional features (file storage, wiki) use the same PHP process. Neither is particularly resource-hungry for a social platform.
Community and Support
Friendica has a larger and more active community. The project has 1,500+ GitHub stars, regular releases (quarterly cadence), and good documentation at friendi.ca. Several public instances run Friendica (e.g., libranet.de), providing a visible federation network. The official Docker image is maintained by the core team.
Hubzilla has a smaller community (~600 GitHub stars) centered around its official forums (hub.netzgemeinde.eu). Development continues but at a slower pace. Documentation exists but is less structured than Friendica’s. The project’s ambition — nomadic identity, CMS, wiki, cloud storage — means fewer developers spread across more features. The Docker situation (community images only, no versioned tags) reflects lower community investment in containerized deployment.
Use Cases
Choose Friendica If…
- You want a Facebook-like experience that federates with the Fediverse
- ActivityPub compatibility is important (interacting with Mastodon, Pixelfed, Lemmy users)
- You prefer an official, versioned Docker image with straightforward setup
- You want a pure social network without CMS/wiki/storage features
- A larger community and more active development matter to you
Choose Hubzilla If…
- Nomadic identity is a priority (your account survives server shutdowns)
- You want social networking + wiki + CMS + file storage in one platform
- Fine-grained permissions matter (per-post, per-contact access control)
- CalDAV calendar and WebDAV file access are useful
- You’re comfortable with community Docker images and manual setup
Final Verdict
Friendica is the more practical choice for most self-hosters wanting a federated social network. Its official Docker image, better ActivityPub support, larger community, and focused feature set make it easier to deploy and maintain. It does one thing well: federated social networking with a familiar Facebook-like interface.
Hubzilla’s nomadic identity is genuinely innovative — no other platform lets you seamlessly clone your account across servers. But this feature requires other Hubzilla users on other Hubzilla instances to be useful, and the network is small. The bundled CMS, wiki, and file storage features are nice but compete with better standalone alternatives (BookStack for wiki, Nextcloud for files). Unless nomadic identity is specifically what draws you, Friendica delivers a better social networking experience with less setup friction.
FAQ
Can Friendica and Hubzilla users interact with each other?
Yes. Both support ActivityPub and Diaspora protocols. A Friendica user can follow a Hubzilla channel and vice versa. Some advanced features (Hubzilla’s permission system, nomadic identity) don’t translate across protocols, but basic posts, comments, and reactions work.
What is nomadic identity?
Hubzilla’s nomadic identity (via Zot6 protocol) lets you create clones of your channel on multiple Hubzilla instances. All clones sync automatically. If one server goes offline, your other clones continue working with all your contacts, posts, and permissions intact. No other federated platform offers this.
Is Hubzilla a fork of Friendica?
Not technically. Hubzilla was built from scratch by Friendica’s original creator (Mike Macgirvin) as a reimagined platform with different architecture. They share PHP/MySQL foundations and some conceptual DNA, but the codebases are independent.
Which integrates better with Mastodon?
Friendica. Its ActivityPub implementation is more mature and treated as the primary federation protocol. Hubzilla’s primary protocol is Zot6, with ActivityPub as a secondary bridge. Mastodon users following a Friendica account generally have a smoother experience than following a Hubzilla channel.
Can I run either on a Raspberry Pi?
Both can run on a Raspberry Pi 4 with 4 GB RAM, though performance won’t be snappy. Friendica with Redis caching will be more responsive. Hubzilla’s additional features (wiki, file storage) add overhead but aren’t dramatic. For either platform, expect slow page loads with more than a handful of active users on Pi hardware.
Related
Get self-hosting tips in your inbox
Get the Docker Compose configs, hardware picks, and setup shortcuts we don't put in articles. Weekly. No spam.
Comments