FreshRSS vs Miniflux vs Tiny Tiny RSS

Remember RSS? Everyone said it was dead. Podcasts killed it. Twitter killed it. The algorithm killed it.

Yeah, and then the algorithm started showing you paid ads instead of your friends, and suddenly hundreds of thousands of people dug RSS out of the tech graveyard and said, “Wait, we can just… host this ourselves?”

If you’re one of them—and if you’ve decided a commercial feed reader is either too expensive or too invasive—you’re looking at three names that keep coming up: FreshRSS, Miniflux, and Tiny Tiny RSS. They all do the same job (read RSS feeds). They all run on your box. They all cost zero dollars. But they’re almost aggressively different in how they get there.

This is the comparison that should’ve existed six months ago.

Why RSS Self-Hosting Still Matters in 2026

Let’s get the obvious out of the way: you probably have 500+ unread articles somewhere. Maybe you’re subscribed to 80+ tech blogs, dev blogs, hobby blogs, newsletter RSS feeds. Your “catch up later” folder is a lie. Cloud services have gotten weird and greedy. Your feed reader shouldn’t require monthly payments, shouldn’t phone home to California, and shouldn’t suddenly shut down because the founder got bored.

Self-hosting RSS is the 2 AM version of this problem: you’re not trusting someone else’s uptime. You control your data. You pick the features. You can run it on hardware you already own.

But the three major contenders are very different machines. Let’s kick the tires.

FreshRSS: The Polished Community Darling

FreshRSS is what you think of when someone says “self-hosted RSS.” It’s PHP-based, lovingly maintained, has a real community, looks modern without being precious, and just works. If you want a safe default, this is it.

Install & Footprint

services:
  freshrss:
    image: freshrss/freshrss:latest
    container_name: freshrss
    environment:
      CRON_MIN: '*/6'
    ports:
      - "8080:80"
    volumes:
      - freshrss_data:/var/www/FreshRSS/data
    restart: unless-stopped

volumes:
  freshrss_data:

That’s it. Pull it, docker compose up, hit http://localhost:8080, create an account, import your OPML. Done in five minutes.

FreshRSS uses SQLite by default—no database to manage, no Postgres daemon to babysit. It’ll happily run on a Raspberry Pi 4 with 2 GB of RAM. The whole thing (including history, read state, custom categories) lives in a single data volume.

Disk footprint: ~150 MB for the image, maybe 500 MB–2 GB of data depending on how much article content you cache. That’s nothing.

UI & Features

FreshRSS has the most polished interface of the three. Feed grid, dark mode, keyboard shortcuts, article preview pane, full-text reading mode. The UI actually feels like someone cared about how you spend time in it.

Multi-user is built in. You can invite family or run it for a small team. Permissions are granular—read-only accounts, per-feed subscriptions, the whole thing.

Extensions are where FreshRSS shines. There’s a plugin ecosystem: custom themes, Fever API emulation, Wallabag integration for read-it-later, custom feed parsing, analytics, full-text scraping improvements. The community has been productive here.

Performance Notes

FreshRSS uses PHP-FPM under the hood. It’s fast enough for 1000+ subscriptions, but you’ll feel the overhead compared to Go. Feed updates are asynchronous (via cron), so you won’t block the UI while it’s refreshing 200 feeds.

With 1000+ subscriptions running on a shared VPS with 2 GB RAM, you’re fine. With 10,000, you’ll start thinking about Postgres. With 50,000… move on.

Mobile Client Support

This is where FreshRSS has a huge win. Because it emulates the Fever API, apps like Reeder, Readrops, and FeedMe all work seamlessly. You get native iOS/Android clients without any nonsense. It also has its own API, so NewsFlash (desktop) and various other readers play nice.

Miniflux: The Minimalist’s Choice

Miniflux is the opposite of FreshRSS. It’s a single Go binary, 6 MB, runs on your potato, and has opinions about what you don’t need.

Install & Footprint

services:
  miniflux:
    image: miniflux/miniflux:latest
    container_name: miniflux
    environment:
      DATABASE_URL: "postgres://miniflux:password@postgres:5432/miniflux?sslmode=disable"
      RUN_MIGRATIONS: "1"
      CREATE_ADMIN_USER: "1"
      ADMIN_USERNAME: "admin"
      ADMIN_PASSWORD: "changeme"
    ports:
      - "8080:8080"
    depends_on:
      - postgres
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    container_name: miniflux_postgres
    environment:
      POSTGRES_USER: miniflux
      POSTGRES_PASSWORD: password
      POSTGRES_DB: miniflux
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  postgres_data:

Wait—it requires Postgres. That’s the trade-off. Miniflux is lean and mean because it offloads state to Postgres. No SQLite, no half-measures.

The upside: the binary is tiny, startup is instant, and it scales to 100,000 subscriptions without breaking a sweat. The downside: if you wanted to run this on a Raspberry Pi without a separate database, you’re out of luck.

UI & Features

Miniflux’s interface is stripped down. Single-pane view of unread articles. Sidebar with feed categories. That’s your experience. It’s fast because there’s barely any JavaScript. The design is minimalist in the sense that it respects your time—every pixel is doing work.

But here’s what’s missing:

• No multi-user out of the box (you can fudge it with a proxy, but it’s not native)
• No plugins or extensions (just env vars and webhooks for the hardcore)
• No grid view or fancy theme system (light, dark, whatever)
• No full-article scraping built in (you can point to a custom scraper, but that’s on you)

This is by design. Miniflux’s philosophy: “We read feeds. Anything else is scope creep.”

Performance & Database Choice

This is where Miniflux flexes. A single Miniflux instance can handle 100,000+ subscriptions because it’s written in Go and delegates data persistence to Postgres. Feed updates are parallelized. Memory usage stays flat regardless of subscription count (you’re streaming from the database, not loading it all into RAM).

If you’re a feed hoarder with 5,000+ subscriptions, Miniflux is the only one that won’t make you nervous.

Mobile Client Support

Miniflux emulates the Fever API and has its own native API. So Reeder, FeedMe, NewsFlash—all work. There are also Miniflux-native apps like Minion (iOS) and Miniflux Reader (Android), though the community ones are more polished.

The Fever API compatibility is a backdoor to the entire Fever ecosystem, which is dead but whose apps still work. That’s a feature.

Tiny Tiny RSS: The Feature-Laden OG

TT-RSS (if you pronounce it out loud, it’s fun) has been around since 2007. It’s the granddaddy of self-hosted readers. It has everything. It also has a famously prickly maintainer and a reputation for… shall we say, “strong opinions about design.”

Install & Footprint

services:
  ttrss:
    image: cthulhoo/ttrss-fpm-pgsql-static:master
    container_name: ttrss
    environment:
      DB_HOST: postgres
      DB_USER: ttrss
      DB_PASS: password
      DB_NAME: ttrss
      TTRSS_SELF_URL_PATH: "http://localhost:8080/"
    ports:
      - "8080:80"
    depends_on:
      - postgres
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    container_name: ttrss_postgres
    environment:
      POSTGRES_USER: ttrss
      POSTGRES_PASSWORD: password
      POSTGRES_DB: ttrss
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  postgres_data:

TT-RSS also requires Postgres. It’s PHP-based, so it’s slightly heavier than FreshRSS (PHP-FPM still, but with more cognitive load).

The image is around 200 MB. Data footprint depends on your article cache—similar to FreshRSS, but the UI is older-looking and heavier on the database.

UI & Features

TT-RSS’s UI looks like it was designed in 2015. It’s not bad, just… vintage. Dark theme is supported. There’s a feed tree sidebar, article list, and reader pane. You can customize basically everything with plugins.

Plugins are the entire story here. TT-RSS’s plugin system is extensive. There are plugins for:

• Full-text scraping (Af_Readability)
• Fever API emulation (Af_Feverbee)
• Custom themes
• Feed filters and routing
• Custom parsing for malformed feeds
• Feed-specific custom CSS injection
• Basically anything you can dream of

The catch: the plugin ecosystem is… let’s say “curated.” The maintainer has strong opinions, and not all community plugins are maintained. Installing plugins requires direct filesystem access or git repos. It’s not a UI button.

Performance & Complexity

TT-RSS’s database schema is dense. It handles massive subscriptions (1000+) just fine, but it’s more resource-hungry than Miniflux and less user-friendly than FreshRSS. PHP-FPM overhead + Postgres overhead + complexity overhead.

On a modest VPS, TT-RSS will ask more of you than the other two. Update processes are manual or cron-based. You might need to tweak memory limits in PHP. The docs assume you’re comfortable with Linux and databases.

Mobile Client Support

TT-RSS has a Fever API emulator, so all the Fever clients work. But the Fever implementation is older, so newer clients sometimes have quirks. It also has its own API, but fewer apps target it natively.

If you care about the mobile experience, TT-RSS is the weakest of the three here.

Feature Matrix: The Head-to-Head

The Real Tests: What Matters

Full-Text Scraping

All three can fetch article bodies, but the execution differs.

FreshRSS has Wallabag integration and can use custom parsers. Setting it up is straightforward—one extension, and you’re good.

Miniflux doesn’t scrape by default. You need to point it at an external service (like Readability or a self-hosted Mercury parser). If you want this, it’s extra work.

TT-RSS has Af_Readability out of the box (if you install it), and it’s solid. But installation feels manual.

Filter Rules & Feed Management

FreshRSS has feed rules built in: mark-as-read rules, category rules, action rules. The UI is intuitive.

Miniflux has basic rule support via API/config, but the UI is bare bones.

TT-RSS has filters as plugins, and they’re powerful but require you to know what you’re doing.

Import/Export

All three support OPML import/export. FreshRSS and Miniflux do it in the UI. TT-RSS also supports CLI. All are solid here.

Which One Should You Pick?

Pick Miniflux if:

• You have 1000+ subscriptions and want zero stress
• You like software that does one thing well
• You don’t mind running Postgres (you should be running Postgres anyway)
• You want the fastest, leanest reader with the smallest memory footprint
• You plan to sync across multiple devices via Fever API

Pick FreshRSS if:

• You want the most balanced experience
• You like having multi-user support without workarounds
• You want plugins and extensions without leaving the UI
• You’re running this on modest hardware (Raspberry Pi, NAS, shared hosting)
• You want the prettiest interface
• You want full-text scraping that just works

Pick TT-RSS if:

• You’ve already been using TT-RSS for years and love it
• You want the deepest customization via plugins
• You don’t mind troubleshooting PHP and Postgres quirks
• You’re the type who reads the source code to understand how things work
• Honest take: you probably shouldn’t pick this one unless you have a specific reason

The Honest Take

Miniflux is the future. It’s what a modern RSS reader looks like: fast, opinionated, and dependency-light (apart from Postgres, which is table stakes these days). If you’re starting fresh, Miniflux is the default.

FreshRSS is the all-arounder. It’s the Goldilocks choice—not as light as Miniflux, not as feature-heavy as TT-RSS, but comfortable enough for 95% of self-hosters. The UI is nicer, the plugin ecosystem is healthier, and you can run it without Postgres.

TT-RSS is for people who already love it or who want to build something that no one else has thought of yet. It’s powerful, but you’re playing on hard mode.

Here’s the thing: you don’t need to pick perfectly. They all read RSS feeds. They all work on your hardware. If you pick wrong, you can export your OPML and switch in an afternoon. That’s the whole point of self-hosting.

So grab a Compose file above, give one a shot, and spend your 2 AM debugging energy on something that actually matters—like figuring out what 500 unread articles are worth keeping.

Related Reading

• Atuin: Shell History That Actually Works Across Machines
• BookStack vs Wiki.js: Picking Your Self-Hosted Documentation Platform
• Escaping Zim: Migrate to Obsidian
• Karakeep: Self-Hosted Bookmarks With AI Tagging
• Linkding vs Hoarder vs Wallabag in 2026