The Do-Everything System: An in-depth review of Hubzilla 3.0.

Sean Tilley
We Distribute
Published in
20 min readFeb 27, 2018


As a platform, Hubzilla holds a tremendous amount of versatility and depth in what it can do. Mike Macgirvin, the platform’s creator, has famously quipped that the system does not have a commercial analogue to draw comparisons to — it’s not just a social network, it’s not just a forum, it’s not just a cloud storage solution, and it’s not just a content management system.

According to the definition on the project website:

Hubzilla is a powerful platform for creating interconnected websites featuring a decentralized identity, communications, and permissions framework built using common webserver technology.

So what does that mean, and who is this for? Let’s dive in to the latest release, and walk through this system one step at a time. There’s a lot of different features and aspects to this platform, which is partially why it’s so difficult to apply one standard label to it.

Table of Contents

  1. Installation — use the LAMP stack, or don’t
  2. Channels and You — What is a channel, and what can you use it for?
  3. Privacy Architecture — Decentralized Access, Nomadic Identity, Channel Cloning
  4. Setting Up a Channel — configuring a profile and settings,finding people, formatting and curating content
  5. Features — Events, Calendar, Cloud Storage, Wiki, Chatrooms
  6. Plugins — Games, Additional Federation Protocols, Cross-Posting, Other Things
  7. Building With Hubzilla — How to write a theme, working with the Commanche Templating System, Writing Widgets, Publishing Web Pages
  8. Community — assessment and resources
  9. Verdict — The Good, the Bad, the Ugly, and who Hubzilla is intended for


By default, Hubzilla runs on the LAMP stack — that’s Linux, Apache, PHP, and MySQL. If you have any experience with setting up Wordpress, Drupal, or a phpBB installation, you’ll feel right at home here. The project provides no-frills instructions on how to get a standard Debian-based installation up and running.

The setup checklist highlights important libraries and configuration settings, pretty much a standard expectation for apps running on the LAMP stack.

If you’re feeling adventurous, it is possible to go off of the beaten path and substitute components — for example, you can set up an installation that sits on top of FreeBSD + Nginx + Postgres, and you may see significant performance gains in doing so. The caveat is that it’s up to the sysadmin to determine how best to configure those components.

Most of this setup and configuration were extremely straightforward. The only tricky part I experienced here was in setting up a mail tool to send out service emails for my hub. Ultimately, I settled on postfix after asking for advice.

Channels and You

The first thing to understand about Hubzilla is that every user has a channel. This is a central concept to how the whole thing works.

What is a channel, exactly? Basically, it’s a space on the web that contains its own stream, one of which is populated with various objects and provides a permissions system and mechanism for subscribers. With this in mind, channels can be used for:

  • A personal wall
  • A celebrity or brand page
  • A bot that pulls content from different places on the web
  • A group where posts are received by all members
This is my channel, which I’ve purposefully altered to resemble a Facebook profile.

Conceptually speaking, any channel can be one of those four things. Any channel can cross-interact with any other kind of channel. It’s even possible to set up a channel to act as a feed bot, pulling in statuses and interactions from multiple sources upstream.

In this case, the Friendica updates channel pulls in Git Commits, Community News, and developer group communications into a single stream.

Forum Channels

Forum channels are particularly noteworthy because they are analogous to Facebook Groups. Hubzilla uses the bang syntax, a tried and true convention used by GNU Social and its predecessor StatusNet.

Just type an exclamation mark, and you’ll be able to mention entire forums instead of individual people.

That’s all you have to do, and in turn everyone that’s subscribed to the forum channel will get your post. From there, they’ll be able to send their interactions back to the relay for participants to retain each other’s responses.

This model is well-suited to ad-hoc group communication, and as a result the community around Hubzilla uses them effectively. Some channels focus on playing chess, others talk about TV series, and some focus exclusively on the project itself.

The Stream

Hubzilla’s network stream is comparable to what you’d expect with Facebook or Diaspora. It shows all of the content coming in from your channel’s connections, and includes status updates, photos, comments, and reshares. Because the platform is not a microblogging network, statuses are threaded together with comments.

As a bonus, certain widgets can extend the functionality of how your stream is used. For example, you can filter statuses by Privacy Groups (comparable to Diaspora’s Aspects) or you could filter by hashtags or dates, or by contact affinity. One of the most useful widgets I use also connects me directly to forum channels, so that I can easily interact with them without leaving my stream.

Incidentally, it’s possible to write entirely custom widgets, but we’ll get into that later.

Privacy Architecture

From the ground up, the platform is built around user privacy. The core design philosophy revolves around giving users a permission system so that they can define who should receive something, and who should see it.

This is no small undertaking — every feature and every function ties into two things: permissions, and decentralized access. Hubzilla is capable of defining who is eligible to receive a piece of data, and who is allowed to access a resource that lives in a particular space online.

Decentralized Access

The decentralized access component of Hubzilla is called OpenWebAuth, and it’s something that no other federated web platform currently offers.

Most traditional systems rely on privately sending everything between mutually connected servers — status updates, images, files, videos, and likes are all pushed back and forth through a relay system. This can cause significant scaling issues, and as a side effect, most federated systems are constrained to send only a few types of activity objects to each other.

Hubzilla, by contrast, only sends status updates, interactions (editing a post, updating your profile), likes, and messages. Everything else lives natively on the host server, and if someone wants to access something from you, they’ll have to visit you.

The beauty of this is that Hubzilla is designed to recognize who is visiting, and grant permissions as necessary. Hubs are contextually aware of who is accessing a resource, be it a page, a comment form, a wiki, or anything else the system can provide.

This experience is seamless, and can make two connected spaces on the web act as if they were one. All of the system’s features are built around this concept, meaning that you can play chess, edit a wiki, comment on someone’s photo, access a file, or message a group through someone else’s website.

Nomadic Identity

Hubzilla’s core is built on a concept called Nomadic Identity, and it’s something that greatly differentiates Hubzilla from other federated platforms.

The idea is relatively simple: your channel does not have to be tied to a specific domain or a particular hub. Instead, it is entirely possible to migrate your posts, files, and contacts to another server, and you can connect multiple channels together to act as a relay system for every post you make.

Channel Cloning

Cloning a channel is a relatively straightforward process: export your channel and profile data, and provide it for upload when registering an account on a different server. You can decide at any time which of your cloned channels will serve as a primary, and which will serve as a secondary relay.

Both channels connect to one another and can act as relays to reshare each other’s resources, contacts, statuses, and permissions.

It’s worth noting that when you post from one channel, your connected clones will relay that post on whatever hubs they’re on, and vice versa. This actually makes the platform relatively censorship-resistant, as a channel could theoretically have many clones across the federated web.

Setting up a Channel

Registration Process

The initial registration process can seem intimidating at first to newcomers. Upon registering, users are prompted to create their channel, set permissions, then edit their profile details and start uploading pictures. Profiles feature an extensive set of fields, most of which are optional and can be updated at a later time.

One interesting side feature of profiles is that it’s able to create “things” and append them to your profile. What exactly is a thing? It’s essentially a small object containing a few metadata fields that lives in your profile section.

You can append things with verbs such as “has”, “wants”, “likes”, or “dislikes”, and you can use that to build small lists on your profile organized by those verbs.

Overall, it feels a little gimmicky, but at the same time it serves as a nice stand-in for the lists you might expect on a Facebook profile. It also allows your other Hubzilla contacts to like those objects as well, without relying on a service-wide like graph.

Finding Contacts

One of the first thing you’re going to want to do when using Hubzilla is find some channels to connect with. By default, Hubzilla connects to a directory system of known channels who have opted in from all across the network. It’s possible to use the directory to find active channels based on interests as well as locations.

Some channels in the directory are inactive or abandoned, but many of them are active within Hubzilla’s small, tightly-knit community. Additionally, the directory can show you all channels present on your own hub, which can be handy for people who want to use the platform to build a community of their own.

Formatting Content

Out of the box, Hubzilla uses bbcode for formatting text. For anyone that has extensive experience in using PHP message boards (vBulletin, phpBB, and SMF come to mind), the syntax and conventions will be all-too-familiar.

To make things a little easier, the formatting pane includes most of the buttons you would expect when writing a post, and it works as advertised.

Posts in Hubzilla give the impression of being somewhere between a status update, a forum post, and a blog entry. In truth, you can easily use it for either purpose, and all posts can include HTML content, media, and attachments. Upon toggling certain features, posts can also include voting tools for proposals, and can even accept sticker responses.

If writing all of your posts in BB markup isn’t in line with your tastes (hello, 2004!), don’t worry! It is also possible to switch to using Markdown by default, which ultimately requires you to type fewer characters.

Tagged Content

This platform leverages two methods for tagging: traditional hashtags, as well as category tags. The main difference is that hashtags are used to find all related posts that a hub knows about, whereas category tags are more useful for providing a topical filter on your channel’s landing page.

If you end up using post tags, they’ll be displayed on your channel as a filter for similar tagged content. This is a fairly standard expectation of blogging platforms, but it’s a million times more organized than what Facebook’s timeline can offer. As a bonus, you can use these to filter subscription feeds — for example, if you’re part of Planet Gnome and only want to syndicate your Gnome-related posts over there, you can do that.


In some circumstances, you’ll receive comments from people that you aren’t connected to. Sometimes it’s a person who just wanted to offer their thoughts on your post. Other times, it’s a spam bot. Hubzilla makes it easy to moderate comments coming from people you don’t know, giving you the opportunity to decide what to keep and what to discard.

In almost every circumstance I’ve had so far, it’s been a bot. I’m vaguely reminded of how this used to happen to my old Wordpress blogs.



The platform ships with an events system, and overall it’s comparable to MeetUp or Facebook Events.

Creating an event will place a marker for it on your channel’s calendar, making it easy to keep tabs of what’s going on at a monthly, weekly, and daily view. Clicking any event will bring up a lightbox with a direct link to an event’s post.

One added benefit of calendar events is that they get inserted into your channel’s stream upon creation. People who can see your event can decide on their attendance, in turn adding your event to their own calendars.

Photo Albums

At first glance, the photo album functionality is quite similar to what you’d expect from Facebook, DeviantArt, or even Flickr. Photos can be sorted into individual albums, given captions, and allows users to tag each other in pictures.

If a photo contains EXIF data, Hubzilla will allow a user to show where the photo was taken using OpenStreetMap tiles. Individual albums can also be embedded into different widgets on your site, making it easy to build out an artwork showcase or a wedding gallery.

One nice bonus here is that any photos that you upload to your channel will instantly be put into cloud storage, making it very easy to retrieve entire albums from a file manager.


One of the things that really sets Hubzilla apart from other communication platforms is its inclusion of permissions-based cloud file storage. When enabled, the system provides a DAV share that can be accessed either by way of browser, or through your local file manager.

Accessing the DAV share through the macOS Finder is trivially easy; the same is true for Windows Explorer and *nix-based file managers

As far as behavior is concerned, the use case is not unlike using Dropbox or Nextcloud. One interesting feature is that all of your photo albums are stored here as well, so it’s easy to always retrieve your pictures when needed.

As a bonus, you can choose to share files in cloud storage with your contacts at the click of a button, and create a status update for a selected audience to see it.

It takes a little bit of getting used to, but overall this core feature ranks as one of the more powerful and intuitive parts of the the platform. This feature can effectively replace iCloud, Google Drive, or DropBox with a decentralized solution.

Calendar Sync

Another neat aspect of Hubzilla’s cloud sharing capabilities is the ability to sync calendars and addressbooks across various different clients. This effectively allows Hubzilla to act as a drop-in replacement for iCloud’s Calendar system

The web calendar and my mobile calendar showing the same event side-by-side.

In my testing, I was able to connect and sync calendar events between Android, GNU/Linux, and Hubzilla’s native web interface. There’s a great community guide that demonstrates how to treat CalDAV as a native resource in Android.

But…it worked just fine in GNU/Linux…

Unfortunately, I had difficulties with getting it to work for the native Calendar app on macOS, but I have no doubt that this may work in the near future — the main issue resided with how Apple’s Calendar app leverages DAV integrations. This is an area of Hubzilla that is a little bit under-documented, as the core audience at this moment is predominantly GNU/Linux users.

One other neat thing is that you can import iCal feeds from other websites. This makes it possible to track events from your favorite venues or groups, and each calendar is also provided for any devices that the calendar is being synced with.

The only real downside is that the Events calendar and your personal calendar are two different systems that don’t touch each other, and some of the functionality does not overlap between these two places. At some point in the future, it is hoped that these two things will be bridged together.


Another great feature that integrates directly into channels is Hubzilla’s wiki system. Users can create an indefinite amount of wikis for a given channel, and create markdown-formatted pages for each wiki.

Creating wiki pages and formatting content is fairly straightforward, and provides the basic set of features for what you’d expect from a wiki system. Pages can link together, images can be embedded from your photo albums, and changes can have a revision message included for posterity.

The edit page, featuring standard markdown. One nice addition here is the ability to embed images from your Photo Album, which makes it easy to grab and reference any pictures already in storage.

It’s also possible to compare changes between revisions and revert to earlier versions of a page, which could be useful in situations where multiple people are editing the same wiki.

Every page reflects edits and revisions, along with information about who contributed the change.


The platform ships with a chatroom that people can visit in-browser. Because Hubzilla automatically knows who the visitor is, identity is automatically assigned and permissions are handed out.

The chatroom is relatively simple, and feels like a mashup of Facebook Messenger and IRC, and every interaction happens in real-time. The use-case is not completely obvious in 2018, given the plethora of dedicated messaging apps out there, but it’s still a welcome addition to the platform.


Like Wordpress or Drupal, Hubzilla also offers an extensive plugin system that allows site admins and users to greatly increase the platform’s functionality. Some of these plugins are purely cosmetic, such as the ability to set a default landing page for logged in users, while other plugins dramatically extend what the system is capable of doing.

Hubzilla Chess

Although the plugin largely exists as a proof-of-concept, it is entirely possible to play a game with other Hubzilla contacts. It works as advertised, and movements are recorded by federating comments back and forth with the FEN notation format. As a side effect, it’s possible to rewind through the entire game history and watch the breakdown of moves.

Cross-Platform Federation

Some of the more interesting plugins actually pertain to Hubzilla’s ability to federate. Out of the box, Hubzilla only federates to other instances of itself using the Zot protocol. However, the plugin architecture allows users to federate to Diaspora (and by extension, Friendica), Mastodon, GNU Social, and anything else that manages to speak either OStatus or ActivityPub.

(Left to Right) The same status as seen between Hubzilla, Diaspora, and Mastodon

Unfortunately, not all participants in the conversation will be able to see all of the comments. People on Diaspora can’t see Mastodon comments, and vice versa. This could theoretically be solved if every actor supported one common protocol between them, but we’re still a far way off from that.


For networks that don’t support direct federation, Hubzilla can act as a client app and send over a copy of a post to networks such as Libertree,, Twitter, Wordpress, Dreamwidth, Livejournal, InsaneJournal, and hypothetically any other network that someone writes a plugin for.

Building With Hubzilla

As one of the more active theme developers on the Hubzilla platform, I feel comfortable with developing themes for it. There are several layers to this system that are noteworthy, and as someone who has developed many themes for the platform over the years, I feel that I can provide some special insight here.

Creating a New Theme

By default, the platform ships with a Bootstrap-derived base theme called redbasic. It’s a relatively no-frills theme that provides many views and templates for the core Hubzilla experience.

The redbasic theme, featuring very little customization.

Because of the platform’s high dependency on this theme, it is generally recommended to write a “derived theme”, which overrides defaults based on what is present in your theme folder (CSS, JS, templates, views, etc). When I started getting into Hubzilla theme development, I used this guide to build my first derived theme.

The Layout System

Hubzilla ships with its own templating framework, called Comanche. The project describes it as such:

Comanche is a markup language similar to bbcode with which to create elaborate and complex web pages by assembling them from a series of components — some of which are pre-built and others which can be defined on the fly. Comanche uses a Page Decription Language to create these pages.

Here’s a quick demonstration of how I’m using it on the Network page in my theme. It lives in $themename/pdl/mod_network.pdl, and overrides the defaults provided by the base theme that it’s extending. Keep in mind, this only affects the layout of the Network page. Other views will need to be modified by their own respective mod_{view}.pdl file

A color-coded legend
Regions and widgets, matched up with the color code.

In practice, it isn’t all that different from Drupal’s regions and blocks system, or the widget framework used by Wordpress. It’s incredibly easy to use, and frontend developers can drop their preferred widgets into specific regions.

Any existing widget can be inserted into a region via a Comanche template, and it’s possible to even write your own and use it with the template system.

Writing Custom Widgets

One of the lesser-explored areas of the platform involves the possibility of writing custom widgets. Doing this can greatly extend the functionality of the interface, and fundamentally change how the whole thing works.

A custom user menu that I wrote over a weekend

As someone who doesn’t write a whole lot of PHP, figuring out the conventions for loading and rendering specific object field data took a lot of figuring out. Basically, you’ll need two files: one .tpl file for providing a markup template, and one .php file for populating that template with values from database fields.

Once you’ve got that set up, you’re in business. Just load the widget into a region on your theme. In my case, it was [widget=usermenu][/widget]. Some trial and error was involved in properly building the channel-specific URLs for each link, and some additional logic still needs to be written to hide certain menu items from visitors. As a first attempt, though, I was pretty satisfied.

Web Pages

Any CMS wouldn’t be complete without the capability to create pages, and Hubzilla leverages all of the conventions I’ve just highlighted for that purpose.

Every single page can have use its own layouts, blocks, widgets, and menus to build any kind of page you want. Additionally, all of this can hook into data provided by Hubzilla’s extensive internal API, meaning that you can populate UI elements with data that lives in your channels.

A pretty decent landing page featuring three blocks, a menu, a nested widget, and custom CSS from my Frontier theme, which is built for landing pages.

Working with the Page / Block / Widget paradigm is similar to how Drupal or Wordpress approach this problem, but the interfaces for building these different elements can sometimes feel counter-intuitive.

It’s not always clear when you should develop a block with an HTML content type, or when you should build a block with something else. Because they can all be intermingled together within a page, it’s not entirely clear whether that matters.


Last but not least, I’d like to talk about the Hubzilla community. It is a rather small group, with a few hundred installations and a couple thousand active users. Much of this community has relied on organic growth, with virtually no advertising, promotion, or hype to speak of.

One neat thing is that Hubzilla dogfoods itself for all of its community operations. The project announces its new releases through one channel, community developers talk about their projects through another, and a Support Forum exists to help people who are hosting their own hubs.

The Hubzilla Support Forum is one of the best places to ask for help on incredibly domain-knowledge-specific issues. As a bonus, the entire community infrastructure is also federated, since it all sits on top of Hubzilla.

As far as developer empowerment is concerned, the Hubzilla community is second to none. It is very common to reach out to the community with a request for help, and receive detailed advice the same day that you ask for it. This applies to inquiries ranging from “Why is this badge not updating?” to “How do I hook into specific database fields for a custom plugin that I’m writing?”

For all of the endless platitudes about “The Open Source Community” supporting itself, Hubzilla actually embodies the majority of its positive virtues. A community of people are using a platform and hacking on it together collaboratively, and very little drama exists within the community itself.


My overall ruling on this system is obviously going to be biased; I have been running Hubzilla on my personal server for the past few years, and have followed its development for a very long time.

I’m absolutely blown away at everything this system provides and is capable of. The fact that so many of its bespoke technologies are passed over in favor of other solutions feels downright criminal.So much of what this system provides surpasses what other federated platforms have even begun to think about — aside from Friendica, virtually none of the other popular federated systems even support organized photo albums, and most can only speak one federation protocol.

Hubzilla still has some rough edges, specifically when it comes to mapping resources that are intended to be accessed through different endpoints. One of my biggest frustrations is the fact that it actually ships with two calendar systems — one for events, the other for CalDAV. It has been suggested that eventually events will be synced between the two of them, and I’m willing to overlook such shortcomings because of what the platform and community already provide.

Who is this for?

At this time, Hubzilla is best suited towards people who want to host their own websites that can also act as a cloud storage provider as well as a decentralized social communication platform. It is meant for the homesteaders of the Internet generation, people who want to withdraw from third-party services and data providers.

The good:

  • Highly customizable: views, themes, and templates can be completely written from scratch
  • If you know how to install Wordpress, you probably know how to install Hubzilla.
  • Content Management features that include web pages, a wiki, file storage, status updates, comments, and photo albums.
  • Identity Management works ridiculously well.
  • An extensive plugin system that can be used for anything, from HTML5 games to mapping systems to git repositories
  • You get cloud storage, address book sync, and calendar sync for free
  • A responsive interface that works well on mobile devices
  • A full suite of social networking features — groups, statuses, photo albums, mood reactions, voting tools, pokes, filtering, blocking, tagging, directories, chatrooms, and more
  • An extremely engaged community that isn’t afraid to get their hands dirty in answering questions and investigating problems

The bad:

  • The initial signup and setup process can feel somewhat intimidating
  • Documentation is a mixed bag. Some feature pages hold very little documentation, and you’re left to explore hook lists
  • Although the block / widget / theme system is highly intuitive, the Pages system isn’t super user-friendly yet
  • Aside from file management, integrating DAV resources inside of macOS seems like a non-starter for now

The ugly:

  • Although it’s not hard to set up manual integration points for your OS, nobody has written OS-level integrations for Hubzilla yet. Gnome Online Accounts, for example, is far more likely to provide first-class integrations with NextCloud or Twitter.
  • Although it offers a Twitter-like API that can theoretically be used by some desktop and mobile apps, nobody has yet developed a featureful mobile application specifically for Hubzilla.
  • For some reason, this project gets passed over again and again in favor of platforms that can’t even do 1/10th of what Hubzilla does.

Sean Tilley is an active user of the Hubzilla platform, and uses it on his personal website. He also has developed a handful of themes to change Hubzilla’s core look and feel.



Sean Tilley
We Distribute

Editor of WeDistribute. Obsessed with Free Software and Decentralization. Also makes things, sometimes with Elixir.