Miniflux is a self-hosted, minimalist RSS/Atom feed reader implemented as a monolithic Go web application. It relies exclusively on PostgreSQL for persistence and serves a server-rendered web UI, a comprehensive REST API, and compatibility endpoints for the Fever and Google Reader APIs. The application is designed for low resource consumption and easy deployment, evidenced by its single-binary nature and extensive packaging (Docker, RPM, Deb, systemd). The core strength of the codebase lies in its feed ingestion pipeline, which demonstrates exceptional defensive programming against the chaotic and non-standardized world of web feeds. This pipeline includes robust format detection (RSS, Atom, RDF, JSON Feed), character encoding detection for legacy charsets, a port of the Mozilla Arc90 readability algorithm for content extraction, a highly restrictive HTML sanitizer with SSRF protection, and a DSL-based content rewrite engine. The system supports multi-user authentication (local, OAuth2, WebAuthn), extensive third-party integrations (Discord, Slack, Telegram, Pinboard, etc.), and background job processing for feed refreshes. The codebase exhibits high craftsmanship with clean abstractions, consistent builder patterns, and thorough testing (unit, integration, fuzz). Several components, such as the SSRF-safe HTTP client builder, the readability extraction algorithm, the i18n pluralization engine, and the HTML sanitizer, are isolated, well-documented, and could be extracted for use in other Go projects. The project is actively maintained with modern Go features, zero Dependabot alerts, and a strong CI/CD pipeline. The main maintenance burden is the sprawl of third-party integrations and the monolithic JavaScript frontend, but the core Go server code is exceptionally well-engineered.
Huginn is a self-hosted, hackable automation platform built as a Ruby on Rails application. It allows users to create and chain 'agents' that monitor, scrape, transform, and act on data from hundreds of sources (web, RSS, email, Twitter, Telegram, Slack, OpenAI, etc.) via an event-driven architecture. Agents are polymorphic Ruby classes with a consistent lifecycle: scheduled checks, event reception, and event emission. The system supports Liquid templating for dynamic configuration, OAuth services, file pointers, and background job processing via DelayedJob. The codebase is extensive with 80+ agent types, reusable concerns (WebRequestConcern, LiquidInterpolatable, FormConfigurable), and a comprehensive test suite. While primarily an application, it includes a small research dataset (ANEW sentiment norms) used by a sentiment analysis agent, but the dominant character is clearly a production automation service.
This is a Laravel package that generates RSS, Atom, and JSON feeds for Laravel applications. It provides a configuration-driven approach where developers define feed sources (models or repositories), and the package handles route registration, item resolution, and format-specific rendering. The architecture follows Laravel package conventions with a service provider, controller-based endpoints, and Blade view templates for output generation. The package supports multiple feed formats (RSS 2.0, Atom 1.0, JSON Feed 1.1) with proper MIME type handling and W3C-compliant XML output. It includes a fluent builder pattern for FeedItem construction, validation of required fields, and a Blade component for automatically generating feed link tags in HTML pages. The codebase demonstrates solid Laravel package engineering with comprehensive test coverage using Pest and snapshot testing.
This is a mature Rust library for parsing and serializing RSS feeds (versions 0.90 through 2.0). It provides a complete data model for RSS channels, items, categories, enclosures, and other elements, with support for common extensions like iTunes, Dublin Core, Syndication, and Atom. The library uses quick-xml for efficient XML processing and offers optional builder patterns, validation against the RSS 2.0 specification, and serde serialization. The codebase is well-structured, with clear separation of concerns across modules, comprehensive test coverage (including round-trip read/write tests), and active maintenance with regular dependency updates. It is a solid, production-ready library for any Rust project needing RSS feed handling.
ReactFlux is a modern, customizable web frontend for Miniflux, a self-hosted RSS reader. It is a client-side single-page application (SPA) built with React 19, Vite 8, and nanostores for fine-grained state management. The application provides a rich reading experience with multiple article layouts (list, card, column), dark/light/system themes, keyboard shortcuts, touch gestures, offline support via PWA, and internationalization (6 languages). It communicates exclusively with a Miniflux server through its REST API, handling authentication, feed/category management, article fetching, and status updates. The architecture follows a component-based design with clear separation of concerns: API layer (src/apis), state stores (src/store), custom hooks (src/hooks), reusable UI components (src/components/ui), and utility functions (src/utils). The codebase demonstrates good engineering practices with well-factored hooks for complex behaviors like optimistic entry actions, infinite scroll pagination, and long-press context menus. It also includes a settings schema with versioned migration and import/export, accessible modal and scroll area components, and a feed icon fetcher with fallback chain. While the project is actively maintained and uses modern dependencies, it lacks automated tests and has a large CSS footprint with many responsive overrides. The tight coupling to the Miniflux API and reliance on experimental React Compiler features introduce some maintenance risk. Overall, ReactFlux is a strong example of a feature-rich client-side application with reusable patterns, suitable for developers building similar RSS reader interfaces or learning advanced React patterns.
This repository implements an RSS feed aggregator for corporate tech blogs. It fetches RSS/Atom feeds from a predefined list of company technology blogs, processes and enriches the feed items with metadata (Open Graph data, Hatena bookmark counts), generates aggregated feeds in Atom/RSS/JSON formats, and builds a static website using Eleventy to display the aggregated content. The site features a homepage with recent articles grouped by date, a 'hot' page showing popular articles based on Hatena bookmarks, individual blog pages, and a blog listing page. Updates are automated via GitHub Actions that run hourly on weekdays and every two hours on weekends.
Nextcloud News is an RSS/Atom feed reader app for Nextcloud. It provides a PHP backend (MVC with controllers, services, DB mappers) and a Vue 3 + TypeScript frontend. Users can subscribe to feeds, organize them into folders, read articles with read/unread/starred states, apply keyword filters, import/export OPML, and sync with mobile/desktop clients via REST APIs. Background cron jobs handle feed updates and cleanup. The architecture follows Nextcloud's app framework with scoped dependencies to avoid conflicts. Key entry points include the web UI (Vue SPA), CLI commands (`occ news:*`), and API endpoints (v1-2, v1-3, v2). External dependencies include feed-io for parsing, Guzzle/PSR-18 for HTTP, and Readability.php for full-text extraction. The codebase is well-tested with unit, integration, and BATS tests, and uses modern tooling (Vite, PHP 8.2+).
FeedCraft is a self-hosted feed processing service that transforms raw sources (RSS, Atom, HTML, JSON, search results, inbox pushes) into customized RSS feeds through composable processing pipelines called 'crafts'. The system is a monolith Go backend with a Vue 3 admin dashboard, exposing REST APIs for feed ingestion, transformation (AI-powered translation, summarization, full-text extraction, filtering), and aggregation into 'topic feeds'. The architecture follows a clean separation of concerns: source fetching/parsing, craft processing (atomic operations and flows), engine runtime, and administrative controllers. External dependencies include SQLite/PostgreSQL, Redis, an OpenAI-compatible LLM, a browserless service for dynamic content, and optional embedding APIs for semantic filtering. The codebase demonstrates solid engineering with interfaces for sources, parsers, crafts, and caching, though it carries some migration complexity from legacy craft models to newer ones.
Nextflux is a modern RSS reader client designed for the Miniflux server. It is a single-page application built with React 19, Vite 6, and TailwindCSS 4, featuring a three-pane layout for browsing feeds, articles, and reading content. The application emphasizes offline capabilities through IndexedDB storage via Dexie, allowing users to read feeds without an internet connection. The architecture employs a decentralized state management approach using Nanostores, with separate stores for authentication, settings, feeds, articles, and synchronization. Data persistence is handled through a repository pattern over Dexie, providing typed access to IndexedDB collections. The application synchronizes with the Miniflux server via a background sync service that handles incremental updates, conflict resolution, and optimistic UI updates. Additional features include a global audio player for media attachments, AI-powered article summarization, and extensive customization options through a settings panel. Notable reusable components include a utility library for class merging and helper functions, a dynamic font loading hook, and a custom hook for detecting reduced motion preferences. The UI is built upon a migrating component library (transitioning from HeroUI/Radix to @base-ui/react and then to a Luma/shadcn-based system), demonstrating a commitment to modern UI practices. The codebase exhibits strong modularity and separation of concerns, with clear boundaries between UI, state management, data access, and service layers.