CommaFeed: Self-Hosted RSS Reader with Quarkus and Native GraalVM Builds

Self-Hosted RSS Reading: What CommaFeed Provides

Google Reader closed in 2013, and the options since have been hosted services that monetize through subscriptions or data, or self-hosted tools that require server setup and maintenance. CommaFeed fills the self-hosted category with a design that takes Google Reader as its reference point.

The application is built on Quarkus, a Java framework designed for cloud-native workloads, with a React and TypeScript frontend. Its headline technical feature is native code compilation via GraalVM: the README notes this gives blazing fast startup and low memory usage compared to running on the JVM. For engineers who want a personal RSS aggregator that does not consume significant memory on a home server or VPS, this compilation path is the key differentiator.

CommaFeed is also available as a free public instance at commafeed.com, so engineers can evaluate the application before committing to a self-hosted setup. The README states the public instance has no ads, no tracking, and no data exploitation.

Quarkus Backend, Native Compilation, and Supported Databases

Quarkus compiles Java applications to native executables using GraalVM's native-image tool. The native binary starts in milliseconds and uses significantly less memory than a JVM process at steady state. This matters for self-hosted deployments where the RSS reader may be one of many services running on a single machine.

CommaFeed supports four database backends: H2 (an embedded database that requires no separate installation), PostgreSQL, MySQL, and MariaDB. The H2 option makes the default installation simple: no database server is needed, and the database file is stored in the `data/` directory relative to the working directory. For production or multi-user deployments, PostgreSQL is the typical choice.

The README states that CommaFeed supports thousands of users and millions of feeds. The application is deployed at a public scale via commafeed.com.

Getting Started: Docker, Prebuilt Packages, and Source Builds

Docker is the recommended starting point. Images are built automatically and available at hub.docker.com/r/athou/commafeed. The README also links to PikaPods, which offers 1-click cloud hosting starting at $1/month with a $5 welcome credit and officially supports CommaFeed.

For manual installation, download a prebuilt package from the GitHub Releases page. Two types are available. The native packages (`linux-x86_64`, `linux-aarch_64`, `windows-x86_64`) contain a standalone executable with no JRE dependency. The JVM package is a ZIP containing the `.jar` files, started with `java -jar quarkus-run.jar`.

To build from source:

./mvnw clean package [-P<database> [-Pnative]] [-DskipTests]

The `-P<database>` profile selects the target database: `h2`, `postgresql`, `mysql`, or `mariadb`, defaulting to `h2`. Adding `-Pnative` compiles to native code, which requires either GraalVM (with `GRAALVM_HOME` set) or a Docker/Podman container environment. Use `-DskipTests` to speed up the build.

Arch Linux users can install from AUR, which builds native binaries with GraalVM for all supported databases. Once running, the server listens on http://localhost:8082 by default.

Configuration: Properties, Environment Variables, and Memory Tuning

CommaFeed requires no configuration to run with H2. For other databases, set `quarkus.datasource.jdbc.url`, `quarkus.datasource.username`, and `quarkus.datasource.password`. The README gives connection string examples for each supported database, including the recommended JDBC parameters for MySQL and MariaDB.

Configuration sources, in order of specificity: environment variables in UPPER_CASE, a `.env` file, command-line arguments prefixed with `-D`, and a `config/application.properties` file in kebab-case. The README recommends the properties file because CommaFeed will warn about invalid keys and typos.

Session encryption uses a randomly generated key by default. This means every restart requires users to log in again. To persist sessions across restarts, set `quarkus.http.auth.session.encryption-key` to a fixed string of at least 16 characters.

For the JVM package, memory can be capped with `-Xmx256m`. The README documents a set of G1GC flags for dynamic memory release back to the OS:

-Xms20m -XX:+UseG1GC -XX:+UseStringDeduplication -XX:-ShrinkHeapInSteps -XX:G1PeriodicGCInterval=10000 -XX:-G1PeriodicGCInvokesConcurrent -XX:MinHeapFreeRatio=5 -XX:MaxHeapFreeRatio=10

The README also mentions OpenJ9 as a more memory-efficient JVM alternative to HotSpot.

API Compatibility, OPML, Custom CSS, and Browser Extension

CommaFeed implements two legacy RSS reader APIs: Fever and Google Reader. These protocols are used by native mobile RSS clients, meaning Android and iOS apps designed for those APIs can connect to a CommaFeed instance. This is the primary way to use CommaFeed from a phone without a dedicated CommaFeed mobile app.

OPML import and export handles bulk migration from other RSS readers. The REST API provides programmatic access for custom integrations. A browser extension is available for quickly subscribing to feeds from web pages.

Custom CSS and JavaScript are documented features that let users modify the appearance and behavior of the web interface. The README links to a documentation page for custom CSS. Four layout options and Light/Dark theme support handle basic visual preferences. The application is translated into 25 or more languages and supports right-to-left feeds.

Limitations: Session Restart Behavior, Hosted Instance Constraints, and No Native Mobile App

The randomly generated session encryption key is a real operational inconvenience for self-hosted instances. Every application restart logs out all users until the key is fixed in configuration. The README documents the fix, but it requires a deliberate configuration step.

The free hosted instance at commafeed.com has unspecified limitations compared to self-hosting, referenced in a GitHub Discussions thread (issue #1567). The README does not enumerate these limits in the main document.

There is no dedicated CommaFeed mobile app. Mobile access relies on the responsive web interface or a third-party RSS app that implements the Fever or Google Reader API. Engineers expecting a polished native mobile experience should verify that their preferred mobile RSS client supports one of those APIs and that the API implementation in CommaFeed covers the features they need.

The JVM package requires a Java Runtime Environment. On systems where disk space or memory are constrained, the native package is preferable, but building native requires GraalVM or a container environment, which is not trivial to set up.

CommaFeed Compared to Miniflux and FreshRSS

Miniflux is a Go-based, self-hosted RSS reader. It distributes as a single binary with no JVM dependency, uses PostgreSQL exclusively, and emphasizes a minimal interface. The contrast with CommaFeed is runtime: CommaFeed runs on the JVM (or as a native binary built by GraalVM), while Miniflux runs as a Go binary. CommaFeed supports four databases; Miniflux supports only PostgreSQL.

FreshRSS is a PHP-based self-hosted RSS reader. It requires a web server and PHP, which is a common stack on shared hosting environments. It also implements the Google Reader API. The contrast with CommaFeed is language and deployment: PHP with a web server versus a self-contained Java or native executable.

CommaFeed's Quarkus and React architecture gives it a more complex build path than either alternative if compiling from source, but the Docker image and prebuilt packages make installation straightforward without a build step.

Editorial conclusion

CommaFeed is a good fit for engineers who want a self-hosted RSS reader with native mobile client compatibility, database flexibility, and low memory consumption on the JVM. Docker is the fastest path to a running instance. The JVM package gives database and JRE control; the native package cuts startup time and memory at the cost of requiring GraalVM or a container environment to build. Engineers who prefer a minimal-footprint RSS reader without a Java runtime should look at Miniflux, which runs as a single Go binary. The last push was on 2026-09-24 and the most recent stable release is 7.3.2 from 2026-08-22.

Frequently asked questions

Official sources

1. Athou/commafeed on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases