Lobsters vs Misago vs FlaskBB in 2026: Lightweight Self-Hosted Forums That Skip the 2 GB Tax

The standard advice for “I need a forum” is Discourse. The standard outcome is a 2 GB RAM bill, two containers, a Redis instance, and a Sidekiq process — for a community of 400 people discussing bicycle routes. Discourse is excellent software aimed at large communities with paid ops staff. It is also wildly oversized for a club, a product’s user base, an internal Q&A board, or a research group.

There is a quieter tier of forum software built for exactly that gap, and three of them are still actively maintained in 2026: Lobsters (4,855 GitHub stars, Rails), Misago (2,781 stars, Django) and FlaskBB (2,666 stars, Flask). All three are database-plus-web-app stacks you can run on a single 1 GB VPS. This guide compares them on the things that actually decide a forum deployment: moderation tooling, search, upgrade path, and how much of your evening the install eats.

TL;DR: Quick Verdict

• Lobsters is a link-aggregator, not a general forum. Pick it if you want a Hacker News-style community with tags, karma and hats — and you accept that it is opinionated, invite-oriented, and has no plugin system.
• Misago is the most complete general-purpose forum of the three: Django, PostgreSQL, Redis, a real admin panel, role-based permissions, private threads, and moderation queues. Pick it for a public community that needs modern UX.
• FlaskBB is the smallest and most hackable: Flask, SQLite by default, a formal plugin and theme system. Pick it when you want to extend the forum yourself or run it on 512 MB.

One-line rule: link aggregation → Lobsters; a real community forum → Misago; a forum you intend to modify → FlaskBB.

At-a-Glance Comparison

Decision Matrix: Pick in 10 Seconds

Lobsters — An Opinionated Link Aggregator, Not a Forum

Lobsters was written in 2012 to run lobste.rs and has been maintained continuously since. It is a Rails application with a deliberately narrow feature set: submit a link or text post, tag it, vote, comment in threads, earn karma, receive hats. There are no categories, no private messages, no plugin API, and no federation.

The upstream repository ships a development Compose file that reflects that minimalism — this is the real file, not a reconstruction:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

services:
  app:
    stdin_open: true
    tty: true
    build:
      context: .
      dockerfile: Dockerfile.dev
    volumes:
      - .:/lobsters
    ports:
      - "3000:3000"

Note what is missing: no database service, no cache service. The upstream stack assumes MySQL/MariaDB and memcached reachable from the container, so a production deployment adds them yourself:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

services:
  db:
    image: mariadb:11
    restart: unless-stopped
    environment:
      MARIADB_DATABASE: lobsters
      MARIADB_USER: lobsters
      MARIADB_PASSWORD: change-me
      MARIADB_ROOT_PASSWORD: change-me-too
    volumes:
      - db:/var/lib/mysql

  memcached:
    image: memcached:1.6-alpine
    restart: unless-stopped

  app:
    build:
      context: .
      dockerfile: Dockerfile
    restart: unless-stopped
    depends_on: [db, memcached]
    environment:
      DATABASE_URL: mysql2://lobsters:change-me@db/lobsters
      MEMCACHED_HOST: memcached
      RAILS_ENV: production
      SECRET_KEY_BASE: replace-with-a-long-random-string
    ports:
      - "127.0.0.1:3000:3000"
    volumes:
      - ./config:/lobsters/config:ro

volumes:
  db:

Then initialise the schema and create the first account:

1
2
3
4
5

docker compose run --rm app bin/rails db:setup
docker compose run --rm app bin/rails c
# then, inside the console:
# u = User.new(email: "you@example.com", username: "admin", password: "change-me")
# u.save!(validate: false); u.grant_moderator!

Lobsters’ strengths are cultural as much as technical. The hot-ranking algorithm, tag filtering, and invitation flow produce a specific kind of community — smaller, more technical, less tolerant of low-effort posting. If that is what you want, nothing else in this article comes close. If you want categories, member groups, or a mobile app, look elsewhere.

The weakness is operational: no plugin system means every customisation is a fork, and merging upstream changes across a fork is a monthly chore. There is also no built-in spam defence beyond invitation control.

Misago — The Most Complete Forum of the Three

Misago is a Django forum that has been in development for over a decade and reached a genuinely polished state. It requires PostgreSQL and Redis, and gives you: categories with per-role permissions, thread and post approval queues, report handling, private threads, user profiles with avatars, read-state tracking, and a modern React-powered interface with server-rendered fallbacks.

Its repository ships a Compose file — and the upstream file carries a warning you must read before copying it:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# This compose setup is only meant for local development of Misago itself
# This is not for running your Misago site in docker
version: "3.0"

services:
  postgres:
    image: postgres:15
    restart: unless-stopped
    environment:
      - POSTGRES_USER=misago
      - POSTGRES_PASSWORD=misago
    ports:
      - '127.0.0.1:5432:5432'

  redis:
    image: redis:6
    restart: unless-stopped

  misago:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    environment:
      - POSTGRES_HOST=postgres
      - POSTGRES_DB=misago
      - POSTGRES_USER=misago
      - POSTGRES_PASSWORD=misago
      - SUPERUSER_USERNAME=Admin
      - SUPERUSER_EMAIL=admin@example.com
      - SUPERUSER_PASSWORD=password
    ports:
      - "8000:8000"
    depends_on:
      - postgres
      - redis

Take the upstream warning literally. runserver is a development server: single-threaded, no static file serving, no request buffering. For production, keep the same services but replace the command and put a real proxy in front:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

  misago:
    build: .
    command: gunicorn misago.wsgi:application --bind 0.0.0.0:8000 --workers 3 --timeout 60
    restart: unless-stopped
    environment:
      - POSTGRES_HOST=postgres
      - POSTGRES_DB=misago
      - POSTGRES_USER=misago
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - MISAGO_SECRET_KEY=${MISAGO_SECRET_KEY}
      - MISAGO_SITE_ADDRESS=https://forum.example.com

First-run setup is two management commands:

1
2

docker compose run --rm misago python manage.py migrate
docker compose run --rm misago python manage.py createsuperuser

What makes Misago the strongest general-purpose choice is the moderation model. Reports, approval queues, per-category permissions, and role inheritance are part of the product rather than an add-on. For a public community where moderation is the main daily task, that difference is worth more than any performance metric.

Trade-offs: PostgreSQL is mandatory (a hard blocker for SQLite-only hosts), the stack needs Redis, and customisation happens at the Django-app level — meaning you maintain a fork if you change models.

FlaskBB — The Hackable Minimalist

FlaskBB is a classic Flask application: SQLAlchemy models, Alembic migrations, Jinja2 templates, and a formal system of installable plugins and themes. It defaults to SQLite, which means docker compose up on a fresh box produces a working forum without any external database.

The upstream repository keeps its container definitions under docker/, including a development stack and a release stack. The development stack is explicit about its defaults:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

name: flaskbb-dev

x-flaskbb-env: &flaskbb-env
  DATABASE_URI: ${DATABASE_URI:-sqlite:////var/lib/flaskbb/flaskbb.sqlite}
  REDIS_URL: redis://redis:6379
  SECRET_KEY: ${SECRET_KEY:-insecure-development-key}
  SERVER_NAME: ${SERVER_NAME:-}
  TRUSTED_HOSTS: ${TRUSTED_HOSTS:-}
  SEARCH_BACKEND: ${SEARCH_BACKEND:-sqlite}
  LOG_LEVEL: ${LOG_LEVEL:-DEBUG}
  DEBUG: ${DEBUG:-true}
  MAIL_SERVER: mailpit

Bring it up with the documented command:

1

docker compose -f docker/docker-compose.dev.yaml up --build

Note DEBUG: true and MAIL_SERVER: mailpit — those are development values. For production you flip DEBUG off, point MAIL_SERVER at a real relay, replace SECRET_KEY, and point DATABASE_URI at PostgreSQL if you expect concurrency beyond a few dozen simultaneous readers.

FlaskBB’s real advantage is extensibility. Plugins register through entry points, so installing a .whl in the container adds features without a fork. The first-party set covers private conversations, a portal front page, and social login; third-party plugins add topic feeds, signatures, and polls. Forums built by developers for their own project’s community are usually FlaskBB’s sweet spot.

Upgrades are the standard Flask dance:

1

docker compose exec app flaskbb db upgrade

Pin your plugin versions. A plugin built against an older Alembic head is the single most common cause of a failed upgrade, and the error messages are unhelpfully vague.

Head-to-Head: The Differences That Decide Real Deployments

Moderation. Misago wins, clearly. Approval queues, reports, role inheritance, and per-category permissions are product features. Lobsters has moderator and tag-editor privileges, but the tooling is minimal and deliberately so. FlaskBB sits in between: reports and moderation exist, and you can extend them.

Search. Misago uses PostgreSQL full-text search and behaves predictably on tens of thousands of posts. FlaskBB lets you choose between SQLite, PostgreSQL and Whoosh backends — the SQLite backend is fine for small boards and degrades on large ones. Lobsters’ search is basic query filtering over titles and tags.

Upgrades. All three are migration-based (Rails migrations, Django migrations, Alembic). FlaskBB adds plugin-version coupling. Lobsters adds fork-merge pain. Misago is the most boring to upgrade, which in forum software is a compliment.

Memory. Measured realistically on a single container with light traffic: FlaskBB ~150–300 MB, Lobsters ~350–600 MB, Misago ~500–900 MB. None of them needs 2 GB, which is the entire point.

Community shape. This is the one thing benchmarks cannot answer. Lobsters produces a link-aggregation culture. Misago and FlaskBB are neutral and take on the culture of whoever moderates them.

Deployment Pitfalls That Will Bite You

1. Running Misago’s dev Compose in production. The upstream file says so in a comment. runserver plus DEBUG on a public IP is a security incident waiting to happen.
2. Forgetting the static files step. Django needs collectstatic and a proxy that serves /static/ and /media/; Flask needs an equivalent. Otherwise threads render without CSS and uploads 404.
3. PostgreSQL without tuning. The default postgres:15 container with 128 MB shared buffers is fine for a hobby board and terrible at 200 concurrent readers. Set shared_buffers and work_mem explicitly.
4. Email deliverability. All three send registration and notification mail. Point them at a real relay with SPF and DKIM, or your first hundred registrations land in spam and never return.
5. Backups that omit uploads. Database dumps alone lose avatars and attachments. Back up the upload directory and the database together, or restore produces broken threads.
6. Lobsters fork drift. Every customisation is a fork. Track upstream with a rebase cadence, or the merge becomes impossible after six months.
7. FlaskBB plugin pinning. Record exact plugin versions next to your image tag. An unpinned plugin plus flaskbb db upgrade is how forums go down at 2 a.m.

If you are still deciding whether a forum is the right shape for your community at all, our Discourse vs Flarum vs NodeBB breakdown covers the heavier tier, and the mailing list comparison covers the email-first alternative. For real-time chat instead of threaded discussion, see Mattermost vs Rocket.Chat vs Zulip.

FAQ

Is Lobsters suitable for a general-purpose forum? No. Lobsters has no categories, no private messages, and no plugin system. It is a link aggregator with voting, tags and hats. Use it when that structure is what you want, and choose Misago or FlaskBB for conventional threaded discussion.

Does Misago really require PostgreSQL? Yes. Misago targets PostgreSQL specifically and uses its features for search and concurrency. SQLite and MySQL are not supported deployment targets.

Can FlaskBB run without Redis? Yes. Redis is used for caching and session-adjacent features; the development stack points at it, but a single-container SQLite deployment works without it, at the cost of some performance and background behaviour.

How many users can these handle on one VPS? With 2 vCPU and 2 GB RAM: FlaskBB comfortably serves a few hundred daily readers on SQLite; Misago handles a few thousand daily readers on PostgreSQL with three gunicorn workers; Lobsters behaves similarly to Misago with lower memory use per request.

Do any of them federate with Mastodon or Lemmy? No. None of the three implements ActivityPub. If federation is a requirement, you need Lemmy, NodeBB with its ActivityPub plugin, or Discourse with plugins — not this tier.

What is the upgrade path from one to another? There is no importer between them. Moving means exporting users, threads and posts from the database and writing a mapping into the target schema. Plan the migration before you launch, not after you have 40,000 posts.

💰 想测试你的市场判断力？我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：Polymarket.com