Codingfish Skip to content

Forum software comparison: the best self-hosted and open source boards

Compare forum software two at a time: set any of the 11 catalogued platforms against each other, then read the part that matters — which differences change the decision and which are noise dressed up as criteria.

Compare two platforms

Discourse and Flarum differ on 5 of 5 rows; the differing rows are marked.

CriterionDiscourseFlarum
Runtime Ruby on Rails PHP (Laravel)
Licence GPL-2.0 MIT
Thread model Reading position Linear
Extensions Plugins and themes (Ruby) Extensions via Composer
Hosting Self-hosted or vendor-hosted Self-hosted

A forum software comparison is only useful if it is weighted. Compare forum software by putting two platforms in adjacent columns and you can generate forty rows of difference, thirty-five of which will not change what anyone decides. The rows that do the work are few, and they are mostly not the ones vendors lead with.

There is no single best self-hosted forum software, and any page that claims otherwise is ranking rather than comparing. What there is, for each pair, is a row that decides it — usually the runtime, the licence, the upgrade record or the thread model. Every forum software comparison on this site is built that way: name the deciding row first, then show the rest for completeness rather than for drama.

The tool above lets you compare forum software from the catalogue directly, and the written pairs below go further where the argument needs prose. Both cover open source boards and the two commercial ones, because the best self-hosted forum software for a given community is frequently the one somebody pays for.

The four rows a forum software comparison actually turns on

Runtime comes first because it is the one you cannot change later. Adopting a platform is adopting a language, a database and an upgrade cadence for as long as the community lasts. The question is not which is technically superior; it is which one somebody available to you can already operate. A team that runs PHP will keep a PHP board patched for a decade and will quietly let a Ruby one drift.

Grid placing 11 self-hosted forum platforms by runtime (Ruby on Rails, PHP, Node.js, Python, Scala) against licence position: open licence, open core, or bought outright.
The two axes most shortlists actually turn on. PHP carries the widest choice at every licence position; every other runtime offers one.

Licence second, because it is binary and occasionally expensive. Commercial platforms mean a renewal line and a vendor relationship. AGPL means that if you modify the software and run it publicly, the modified source is owed to your users. Neither is a problem until it is, and both are cheap to check now.

Thread model third, because it shapes the community rather than the installation. Linear boards, reading-position boards and properly threaded boards produce measurably different conversations, and the difference compounds over years.

Extension mechanism fourth, because it decides how the installation ages. Composer-managed extensions fail loudly at install time. Patch-based modifications fail quietly, three years later, during an upgrade nobody has time for.

The rows that look decisive and are not

Feature checklists are the main offender. Private messaging, polls, attachments, tagging, mentions, reactions — every platform in this catalogue has these or has an extension that adds them. A comparison table full of ticks in both columns is not information; it is reassurance.

Theme count is another. The number of available skins tells you nothing about whether the one you end up using will survive the next major release, which is the only question that matters. A platform with six maintained themes is in better shape than one with two hundred abandoned ones.

Benchmark figures deserve particular suspicion. Almost no self-hosted community is performance-bound. Boards die of neglect, spam and moderator burnout; they do not die of requests per second. If a comparison leads with throughput, it is comparing the wrong thing for the reader it has.

Reading a specific pair

Discourse against Flarum is the clearest illustration of runtime deciding a comparison. Both are modern, both are actively developed, both produce a good-looking board. One is a Rails application expecting PostgreSQL, Redis and a container host; the other is a small PHP core that installs where PHP installs. Nothing in a feature table separates them as decisively as that single row.

phpBB against NodeBB separates on thread behaviour and operational shape. phpBB is a request-response board that runs anywhere and has run everywhere for twenty years; NodeBB is a real-time application that wants a process manager and a websocket path through whatever is in front of it. On a busy support forum the real-time behaviour is worth the extra moving parts. On a board that gets nine posts a week it is a liability without a benefit.

XenForo against Invision Community is the comparison where licence is the whole story, because both are commercial, both are mature, and the technical differences are smaller than the differences in what each vendor bundles. Invision is a suite; XenForo is a forum. If the requirement is only a forum, the suite is surface area you will pay for and not use.

Vanilla against Misago is a comparison almost nobody should make on features, because the two are chosen for opposite reasons — one because it embeds into an existing page, the other because the organisation already speaks Django. Either reason settles it before the table opens.

The pairs written out in full

Each one names the row that actually decides it, rather than scoring every row equally.

There is no single best self-hosted forum software — weight the rows yourself

The honest procedure is short. Write down the runtime you can support and cross off everything that does not match. Write down whether a commercial licence is acceptable and cross off accordingly. What survives is usually two or three platforms, and at that point the thread model is the deciding row — which is convenient, because it is also the only one you can judge properly by using them.

Install the survivors. Post into each for a week. The board that feels right when it is empty is the one that will feel right at a thousand posts, because what you are testing is the shape of the thing rather than its capacity.

Comparing open source boards on cost, honestly

Cost comparisons between self-hosted platforms tend to compare the wrong number. The licence is zero for nine of the eleven entries here, which makes the table look decisive and tells you almost nothing, because the licence was never the expensive part.

The three real costs are hosting, upgrades and moderation. Hosting varies more than people expect: a PHP board on shared hosting is a few pounds a month, while a containerised application with a separate database and cache wants a small virtual server and the competence to keep it patched. That is not an argument against the second — it is an argument for pricing it correctly instead of writing zero in the licence column and stopping.

Upgrades are labour, and their cost depends almost entirely on the extension mechanism discussed above. Moderation is labour too, and it is the one that scales with success rather than with the software. A comparison that helps should end with an estimate of hours per month, not a row of zeros.

One figure genuinely worth putting in a comparison is how long a fresh install takes from an empty server to a board accepting registrations. Not because speed of installation matters, but because it is a fair proxy for how many moving parts the thing has, and therefore for how many of them can break later. A platform that is running in twenty minutes and one that needs an afternoon are telling you something true about the next five years.

Comparing when a board already exists

Most people reading a comparison are not starting from nothing. There is a board, it is old, something about it has become intolerable, and the question is whether moving is worth it. That is a different comparison and it has an extra column: what the move costs.

Three things travel badly. Accounts travel worst — password hashes are rarely portable between platforms, so a migration usually means every member resetting a password, and a proportion of them simply not coming back. Attachments travel next-worst, because they are large and their paths are embedded in post bodies. Addresses travel only if somebody makes them, which is the piece most migrations discover afterwards.

Set against that, the honest question is whether the current board is actually failing or merely dated. A board that is unpatchable, unmoderatable or unsearchable is failing and the move is worth the losses. A board that looks like 2009 but works is not, and redesigning the theme costs a fraction of a migration.

Where a move is justified, the comparison should be run in one direction only: from the current platform to the candidates that have a maintained importer for it. That single filter removes more options than any feature row, and it removes the ones that would have hurt.

Two rows worth adding yourself

Whatever table you build, add a column for the date of the last release and a column for where support actually happens. Neither is a property of the software and both predict the experience of running it better than anything that is.

A project shipping releases every few weeks is being maintained; one whose last release is eighteen months old may be finished or may be abandoned, and the difference is visible only in whether anyone is still answering questions. Support location matters for the same reason: a project whose users help each other in its own forum has a different failure mode from one where the only channel is a commercial ticket queue.

What a comparison cannot tell you

Two things stay outside every table. The first is the community around the software — how quickly a question in its own support forum gets answered, and whether the answer comes from the maintainers. That is a five-minute check and it predicts your next three years better than any specification.

That is the limit of any forum software comparison, including this one. It can tell you what each platform is and what it will ask of you; it cannot tell you whether the room will feel right. Compare forum software on the rows, then install the two that survive and post into them for a week — the open source ones cost nothing but an afternoon to try.

The second is the migration path out. Every platform here can import from somewhere; far fewer document what happens to the addresses when they do. A board that has been answering questions for a decade is a search asset, and links point at specific topic addresses. A comparison that ignores this is comparing the first year and not the tenth.

All forum platforms

Every forum entry in the catalogue on the four deciding rows.

PlatformRuntimeLicenceThread modelExtensions
Discourse Ruby on Rails GPL-2.0 Reading position Plugins and themes (Ruby)
Flarum PHP (Laravel) MIT Linear Extensions via Composer
NodeBB Node.js GPL-3.0 Linear, real-time Plugins and themes (Node.js)
phpBB PHP GPL-2.0 Linear Extensions (PHP)
MyBB PHP LGPL-3.0 Linear Plugins and themes (PHP)
Simple Machines Forum PHP BSD-3-Clause Linear Package manager modifications
Vanilla PHP GPL-2.0 (open-source edition) Linear Addons (PHP)
Misago Python (Django) GPL-2.0 Linear Django applications
XenForo PHP Commercial Linear Add-ons (PHP)
Invision Community PHP Commercial Linear Applications and plugins
Talkyard Scala AGPL-3.0 Threaded replies Limited

Questions people actually ask

Which rows actually decide a forum software comparison?

Four: the runtime you are adopting, the licence position, the upgrade record and the thread model. Everything else — plugin counts, theme galleries, feature checklists — differentiates far less than a table makes it look. A comparison that scores forty rows equally has moved the work of deciding which rows matter back onto the reader.

Is there a best self-hosted forum software?

No, and any page that names one is ranking rather than comparing. The answer depends almost entirely on which runtime someone can already support and what shape the conversation takes. What does exist, for each pair, is a row that decides that specific comparison — which is how the written pairs here are structured.

Why are only five pairs written out in full?

Because those are the ones people actually search for. Pairs that are rarely searched were deliberately not published: three thin pages padded to a floor read as generated, which is the opposite of useful. The comparison tool above covers every other combination from the same data.

Do the commercial boards belong in an open source comparison?

Yes, because communities genuinely weigh them against the free options and frequently choose them. XenForo and Invision Community sell a licence and supply the source; what the fee buys is an upgrade path and part of the operational burden somebody would otherwise carry. Whether that is cheaper than the hours it removes is a real question, not a rhetorical one.