Resurrecting Old Content: How Feed-Repeat Keeps Your RSS Feeds Fresh

The RSS Renaissance You Didn't Know You Needed

Let's be honest—RSS feeds had a rough decade. While social media ate the world, RSS quietly became the go-to tool for power users, developers, and anyone who wanted actual control over their information diet. But here's the thing about feeds: they're chronological by default. Your brilliant 2022 post about "The Future of API Design" gets buried under three months of updates, and new subscribers never see it.

This is the problem feed-repeat solves. Built in Haskell by developer Abhinav, this tool takes entries from multiple RSS/Atom/RDF feeds and intelligently reintroduces older content into new output feeds. It's like having a digital curator that ensures your evergreen content gets a second (or third) chance at discovery.

Why Weighted Sampling Makes All the Difference

Random is easy. Random is also useless.

If you just grabbed random old posts, you'd end up with a chaotic feed that confuses subscribers. Feed-repeat uses exponential weighting to prioritize older entries. The logic is elegant: content that's been sitting around longest deserves another shot at visibility. This creates a natural rhythm where your archive gets cycled through systematically rather than lumped together randomly.

The tool also lets you configure:

• Minimum entry age — Never repeat content from the last week
• Repeated entry count — How many old entries to pull per cycle
• Domain-level limits — Prevent one prolific source from dominating
• Selection alpha — Fine-tune the weighting curve

Features Built for Reliability

Feed-repeat isn't just clever—it's production-ready:

Smart Caching — Source feeds go down. Servers hiccup. Feed-repeat caches fetched feeds locally, so temporary unavailability doesn't break your output. The tool gracefully handles the upstream chaos while keeping your downstream feeds consistent.

Multi-Source Aggregation — Configure multiple source feeds with individual parameters. Maybe your tech blog pulls from three industry feeds plus your own archive, each with different sampling rules.

Format Flexibility — Whether you're dealing with RSS 2.0, Atom, or RDF (yes, people still use RDF), feed-repeat handles them all without complaint.

Deployment Options for Every Stack

Here's where feed-repeat gets interesting for developers and operators. The tool offers deployment paths for nearly every environment:

NixOS Users — Full module integration. Define your feed configurations right in your NixOS configuration, and the module generates the systemd service, manages permissions, and even configures Nginx with optional SSL. It's infrastructure-as-code at its finest.

Traditional Systemd — For everyone else running Linux, there's a straightforward systemd service with timer support. The setup requires a few manual steps (creating users, directories, permissions), but the documentation is thorough.

Docker — Prefer containers? Feed-repeat ships as a pre-built image on GitHub Container Registry. Mount your config, output directory, and cache volume, and you're running in seconds. The container runs as a non-root user, which is a nice security touch.

GitHub Pages — Since the output is static feed files, you can serve them directly from GitHub Pages or any static host. This makes feed-repeat perfect for creating aggregated "best of" feeds that you serve for free.

Who Should Care About This?

Technical bloggers with large archives who want subscribers to see their best work, not just recent posts.

Feed aggregators building curated content streams from multiple sources.

Developers who appreciate well-crafted Haskell tools and might want to contribute or fork the project.

NixOS users who want declarative feed management integrated into their system configuration.

Getting Started

The project provides pre-built static binaries for both AMD64 and AArch64 architectures, so you don't need a Haskell environment to run it. If you want to build from source, GHCup makes installing the Haskell toolchain straightforward.

For most users, the Docker approach offers the fastest path from installation to running feeds: pull the image, mount your config, and you're done.

What makes feed-repeat noteworthy isn't just its utility—it's the thoughtful engineering. Exponential weighting, robust caching, multiple deployment paths, and NixOS integration show someone built this for their own workflow and then polished it for others. That's the open-source dream, really.

If you've been wondering how to get more mileage from your content archive, feed-repeat might be exactly the tool you've been ignoring.

Check out the project at github.com/abhin4v/feed-repeat.