Miniflux Is a 20 MB RSS Reader That Reads Faster Than Your Browser

On July 24, 2026, Frédéric Guillot shipped Miniflux 2.3.3 — a maintenance release with 17 bug fixes and language detection for feeds. The binary still clocks in under 20 MB, depends on nothing but PostgreSQL, and runs on a Raspberry Pi without breaking a sweat. Meanwhile, FreshRSS — the other major self-hosted RSS reader — requires PHP 8.1+, the GMP extension, and weighs several hundred megabytes once every Composer dependency lands. This isn’t a debate about which one has more checkboxes. It’s a different question entirely: should your RSS reader really be heavier than the articles it reads?

Miniflux answers no. It’s been proving the point since 2013.

One binary, one database, zero JavaScript frameworks

Miniflux’s technical bet can be stated in a single sentence: every piece of code — backend logic, HTML templates, CSS, vanilla JavaScript, static assets — is compiled into one Go binary using the embed package. No 200 MB node_modules. No PHP-FPM to tune. No Redis. No ORM schema migrations that break every time you update.

The final executable weighs under 20 MB on Linux amd64. For context, FreshRSS’s symfony/framework-bundle alone exceeds that size before Composer even installs the rest of the dependency tree. Miniflux starts in under a second on a €5/month VPS. Its memory footprint sits between 50 and 100 MB RAM when handling hundreds of feeds.

The sole external dependency is PostgreSQL. Not SQLite, not MySQL, not MariaDB — PostgreSQL, period. The project owns this choice on its Opinionated page: supporting multiple databases adds complexity, and PostgreSQL provides native types (jsonb, inet, tsvector) that Miniflux uses directly, with no ORM layer in between.

services:
  miniflux:
    image: miniflux/miniflux:2.3.3
    ports:
      - "8080:8080"
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgres://miniflux:${DB_PASS}@db/miniflux?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=${ADMIN_PASS}

  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=miniflux
      - POSTGRES_PASSWORD=${DB_PASS}
    volumes:
      - miniflux_db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "miniflux"]
      interval: 10s
      start_period: 30s

volumes:
  miniflux_db:

# First launch
docker compose up -d

The web UI is available at http://your-server:8080. Credentials are whatever you set in ADMIN_USERNAME and ADMIN_PASSWORD. The RUN_MIGRATIONS=1 flag runs schema migrations automatically on startup — set it to 0 after the first launch, except when upgrading Miniflux itself.

What Miniflux deliberately doesn’t do

Miniflux’s philosophy is stated plainly on miniflux.app/opinionated.html: “The purpose of this application is to read feeds. Nothing else.” This isn’t a tagline — it’s a filter. Any feature that doesn’t directly serve feed reading gets rejected.

The result: Miniflux has no nested folders, no multi-user permission tiers, no drag-and-drop theme builder, no customizable dashboard, no reading statistics. What you get are categories (flat, one level), stars (favorites), a history log, and full-text search powered by PostgreSQL. That’s it.

This minimalism is a feature for three types of users:

• The power reader processing 200+ articles a day. The interface is optimized for rapid scanning — a headline list, one-line summaries, fully keyboard-driven navigation. j/k move up and down, v opens the article in a new tab, m marks it as read. There’s no animation to slow down your scrolling.
• The self-hoster maintaining a dozen services. Upgrading Miniflux is docker compose pull && docker compose up -d. No composer update, no php bin/console doctrine:migrations:migrate, no cache directory to flush. The binary ships everything.
• The privacy maximalist. Miniflux strips tracking pixels, removes UTM parameters and fbclid from URLs, blocks external JavaScript, and proxies media through its own server to prevent referrer leaks. Even YouTube embeds get routed through youtube-nocookie.com.

It also supports passkeys (WebAuthn), OpenID Connect, and reverse-proxy authentication — you’re not stuck with a local username and password if your infrastructure already uses SSO.

Content scraping: when the RSS feed isn’t enough

Most sites serve truncated summaries in their RSS feeds. Miniflux sidesteps this with a built-in Readability parser — it fetches the original article, extracts the relevant content, and displays it inline, stripped of ads and sidebars.

Better yet, you can write your own scraper rules using plain CSS selectors. Got a site that hides content behind a div.article-body outside the standard feed? Add a rule in the feed settings:

div.article-body
article .content
main .post

Miniflux runs these selectors and extracts whichever block matches. For trickier cases, rewrite rules let you modify the DOM before display — strip a cookie banner, replace low-res images, inject a custom stylesheet.

FreshRSS has a roughly equivalent feature via its XPath extension, but that requires writing XPath expressions by hand. Miniflux’s CSS selectors are more readable and testable right in the browser’s DevTools.

FreshRSS vs. Miniflux: it’s not a philosophy debate, it’s a resource equation

FreshRSS and Miniflux are the two dominant self-hosted RSS readers in July 2026. They don’t play in the same weight class.

The star counts are close, but the trajectories tell a different story. Miniflux is growing faster (+800 stars since January 2026) than FreshRSS (+400). The reason is simple: the self-hosted community is steadily moving away from LAMP stacks toward single-binary architectures.

FreshRSS is still an excellent choice if you need nested folders, advanced multi-user sharing, or your existing infrastructure is PHP-based. For everything else, Miniflux wins on the three metrics that matter in production: deployment speed, resource consumption, and maintenance surface area.

The API turns Miniflux into a universal backend

Miniflux exposes a full REST API, documented at miniflux.app/docs/api.html, with official client libraries in Go and Python. Every operation is covered: feeds, entries, categories, users, stars, history.

The API also speaks Fever and Google Reader protocols, which means you can point any existing mobile app at your Miniflux instance:

• Reeder (iOS/macOS) — Fever API
• NetNewsWire (iOS/macOS) — Fever API
• Lire (iOS) — Fever API
• FeedMe (Android) — Fever API
• News+ (Android) — Google Reader API

You configure your Miniflux URL in the app, and it syncs feeds, read status, and starred articles automatically. Miniflux doesn’t need a native app — its API bridges to every one that already exists.

On the integration side, the 25+ services cover the most common self-hosting workflows: send articles to Wallabag for read-later, push notifications to Telegram and Discord for critical feeds, archive to Linkding or LinkWarden. Webhooks let you wire it into anything with an HTTP endpoint.

Verdict: if your RSS reader weighs more than 20 MB, you’re using the wrong one

The choice between Miniflux and FreshRSS isn’t a matter of preference. It’s a function of your infrastructure and your tolerance for maintenance.

• You have a small server, a Raspberry Pi, or a €5/month VPS. Run Miniflux. The 20 MB binary starts instantly, uses 50 MB of RAM, and stays alive with zero maintenance beyond docker compose pull. The keyboard-driven UI will get you through 200 articles in 20 minutes.
• You run a shared instance for your family or company, with dozens of users and fine-grained permissions. FreshRSS is still the better fit, thanks to its multi-tier profile system and nested folder structure.
• You want the best of both worlds without compromise. Deploy Miniflux as your backend engine and connect it to a mobile client via the Fever API — you get Go’s lightweight performance on the server and native-app ergonomics on your phone.

Whatever you choose, don’t deploy an RSS reader that weighs more than the 200 articles it’ll chew through every morning. Miniflux spent a decade proving that a single binary, a PostgreSQL database, and a keyboard-driven interface cover 95% of what you actually need. Everything else is fluff.

References

• Miniflux — official website — documentation, features, philosophy
• GitHub — miniflux/v2 — 9,500 stars, 3,000+ commits, Apache 2.0 license
• Miniflux 2.3.3 release notes — 17 fixes, language detection, performance
• Miniflux Features — scraping, API, integrations, privacy
• Miniflux — Opinionated — why Go, why PostgreSQL, why no JS framework
• Noted.lol — Miniflux: A Minimalist and Self-Hosted RSS Reader — setup guide and walkthrough
• FreshRSS — GitHub — 10,200 stars, feature comparison
• OSSAlt — How to Self-Host Miniflux 2026 — Docker Compose guide, Fever API