RSS Reader Ranking — Sovereign / FOSS / Privacy‑Maximalist Analysis

Newsboat is a text-console RSS/Atom reader and an actively maintained fork of Newsbeuter. It remains the cleanest balance between operational usability and structural austerity: local by default, highly scriptable, and narrow in purpose. There is no built-in social graph, no hosted dependency, and no need to expose an HTTP service simply to read feeds.

• Privacy & self-hosting: exceptionally high because the software operates as a local program rather than a networked service.
• Attack surface: small compared with PHP/JVM stacks, though not literally zero because feed parsing and text/HTML handling still exist.
• Workflow fit: among the strongest in the entire field; excellent with cron, shell scripts, SSH workflows, and file-based backup patterns.
• Maintenance: current, active, and visible via the official release stream.

Under this scoring model, Newsboat is the default reference point for what a sovereign-node reader looks like: local, inspectable, predictable, durable, and free of unnecessary surface.

sfeed is the purest minimalism entry in the ranking: a small C parser and associated helper tools that convert feeds into structured text and other straightforward formats. It is less a “consumer app” than a composable primitive.

• Attack surface & stack minimality: near maximal because the code is small, local, and free of platform gravity.
• Workflow fit: arguably the strongest in the list for shell-native environments, static generation pipelines, and custom automation.
• Offline & portability: high due to simple text-oriented design and compatibility with file-based backup habits.
• Maintenance: slightly lower than Newsboat, not because the project is weak, but because it is quieter and more frozen-looking upstream.

When the goal is to own the entire pipeline and keep the feed layer as small and transparent as possible, sfeed becomes extremely difficult to beat.

Elfeed is a local Emacs-native feed reader, and with elfeed-org it can be configured from Org files and integrated into deeply programmable text workflows. Its structural advantage is obvious: everything lives inside a local editor rather than behind a web service.

• Privacy: perfect under this model, because the tool is local and does not require any hosted control plane.
• Workflow fit: extremely strong for Emacs/Org users because the surrounding environment is already programmable.
• Attack surface: lower than web apps, but somewhat below Newsboat/sfeed because Emacs itself is a larger substrate.
• Portability: strong via local storage and established config/export patterns.

Elfeed is less universally minimal than Newsboat or sfeed, but for an Emacs-centered environment it is one of the most natural sovereign choices available.

Miniflux is the strongest self-hosted web hub in the list. It is intentionally minimalist, opinionated, and small in scope, with a Go backend and a narrow feature set that avoids the plugin explosion and code sprawl seen in older server readers.

• Privacy: high by design; the project foregrounds minimalism and stripping junk rather than building a social layer.
• Attack surface: inevitably higher than a local TUI because it is an HTTP service, but materially lower than full LAMP/JVM stacks.
• Workflow fit: strong enough for APIs, automation, keyboard navigation, and controlled multi-device access.
• Maintenance: among the strongest server-side projects in the field, with visible release momentum.

For deployments that require a central feed hub but still reject heavyweight architecture, Miniflux is the cleanest compromise.

yarr is a lightweight Go + SQLite self-hosted reader with a minimal web interface. It occupies nearly the same conceptual lane as Miniflux, but with a somewhat more stripped-down and self-contained deployment profile.

• Self-hosting: excellent for a server-side project because the deployment story remains small and direct.
• Attack surface: lower than larger web stacks, though still higher than local readers because the service speaks HTTP.
• Workflow fit: good, though not as rich or polished as Miniflux’s broader ecosystem.
• Portability: helped by SQLite and a compact project footprint.

yarr is what a relatively restrained browser-accessible RSS service looks like when the stack is kept intentionally small.

Liferea is a longstanding GTK/GNOME feed reader that preserves the local-app advantage while delivering a conventional graphical interface. It scores well on privacy and self-hosting because no separate server is required, but it loses ground to Tier 1 because desktop GUI stacks and embedded content renderers are larger and more intricate.

• Privacy: strong, because the reader remains a local desktop application.
• Attack surface: moderated by local-only operation, but still increased by browser/HTML rendering and desktop-framework complexity.
• Maintenance: solid, with an active upstream and clear release history.
• Role: suitable where a native graphical reader is preferred over TUI/Emacs workflows.

Stringer is a self-hosted, anti-social RSS reader built with Ruby and Sinatra. Its ranking improved after repeated audits because the project is clearly active and because its philosophy remains comparatively restrained: the software is oriented around personal feed consumption rather than recommendation systems or broad platform ambition.

• Privacy: high, due to its personal-reader orientation and absence of social/network gimmicks.
• Attack surface: lower than sprawling PHP/JVM stacks, but still non-trivial because it is an HTTP service backed by a database.
• Maintenance: stronger than earlier assumptions suggested.
• Tradeoff: not as small or universal as Tier 1 local readers, and not as broadly polished as Miniflux.

Alligator is a KDE Kirigami-based reader that spans desktop and Plasma Mobile. It inherits the local-application privacy advantage, but also inherits the complexity of a larger Qt/KDE substrate.

• Privacy & self-hosting: strong because the application is local and does not require a separate service layer.
• Attack surface: higher than TUI/Emacs options due to framework and rendering complexity.
• Ecosystem: stronger than many local readers because it bridges desktop and mobile KDE environments.
• Maintenance: respectable, though slightly less clearly active than the very strongest projects in the list.

FreshRSS is a strong, mature, feature-rich self-hosted PHP aggregator with broad client compatibility and a healthy ecosystem. It ranks below Miniflux and yarr primarily because it requires a heavier operational footprint and a more complex multi-user web architecture.

• Workflow fit & interop: strong, especially where APIs and external clients matter.
• Maintenance: visibly healthy and active.
• Attack surface: materially larger than the Tier 2 minimal hubs because of classical web-stack gravity and multi-user logic.
• Use case: entirely legitimate where a richer web reader is deliberately desired.

Akregator is KDE’s established feed reader and part of the wider Kontact / KDE PIM world. Its local-app structure preserves strong privacy and self-hosting characteristics, but the larger PIM substrate pulls down the attack-surface score.

• Strength: local-only operation with respectable maintenance and strong portability.
• Penalty: deeper entanglement with a large desktop/PIM framework compared with more focused local readers.
• Position: a credible KDE-native choice, but less austere than Tier 1 or even Liferea/Alligator in some workflows.

Tiny Tiny RSS remains one of the most flexible and widely interoperable classic self-hosted feed readers. It scores well on workflow fit and ecosystem reach, but repeated audits kept its attack-surface score lower because it is an older, larger, more plugin-oriented multi-user web application.

• Interop: a real strength; many clients and integrations already know how to speak to TT-RSS.
• Maintenance: stronger than early assumptions suggested; the project is alive.
• Penalty: complexity, plugin surface, and the structural reality of a long-lived PHP web stack.
• Position: still viable, but no longer among the cleanest options under a strict minimalism lens.

CommaFeed is a Google Reader-inspired self-hosted personal RSS reader. It remains fully open-source and functional, but under this model it is dragged down by stack weight: a modern JVM + web front-end architecture is simply harder to justify when the same end-state can be reached with substantially less machinery.

• Strengths: familiar web interface, good interoperability, and respectable project quality.
• Weakness: too much platform mass relative to the narrow task of feed aggregation.
• Maintenance: acceptable, but no longer a major momentum leader.

Nextcloud News inherits one of the strongest ecosystem stories in the table, but it also inherits the full weight of the broader Nextcloud platform. That is the decisive penalty.

• Strengths: good sync story, strong interoperability, healthy upstream environment, and a strong mobile/client story inside the Nextcloud world.
• Weakness: far too much platform gravity for a narrowly defined RSS layer.
• Interpretation: fully sensible if Nextcloud is already an intentional core platform; structurally overbuilt if the objective is simply “read feeds with minimal surface.”

Under a strict anti-bloat, anti-synthetic-stack scoring model, Nextcloud News ends last not because it lacks quality, but because it requires the largest supporting infrastructure relative to the narrow function it performs.