Rediscovering RSS: Giving Your Old Content a Second Life

Remember RSS feeds? For a while there, everyone thought social media had killed them off. But here's what actually happened: while the masses were doom-scrolling through algorithmic feeds, a dedicated group of power users and developers kept RSS alive because they understood something important—having control over your information sources matters.

The thing about traditional feeds, though, is that they play favorites. New content always wins. That killer post you wrote two years ago about API design? Buried forever under a mountain of recent updates. New subscribers never see your best work, and that's a real shame.

Meet feed-repeat: The Archivist Your Content Deserves

This is exactly why someone built feed-repeat. Created in Haskell by developer Abhinav, this clever tool pulls content from multiple RSS, Atom, or RDF sources and strategically resurfaces older posts in your output feeds. Think of it as having a digital librarian who makes sure your evergreen content doesn't gather dust in the archives.

The magic here is in the approach. Rather than just dumping random old posts into your feed (which would confuse everyone), feed-repeat uses exponential weighting to intelligently sample from your history. The longer something has been sitting unpublished, the higher its chances of getting pulled into rotation. This creates a natural, systematic cycle through your content library instead of chaotic randomness.

You can tune this behavior with several options:

• Minimum entry age — Set how "stale" content needs to be before it can reappear
• Repeated entry count — Control how many old posts enter each feed cycle
• Domain-level limits — Keep one overly-active source from taking over your output
• Selection alpha — Adjust the weighting curve to match your preferences

Built to Actually Work in Production

Theoretical solutions are nice. Feed-repeat actually works when things go wrong:

Caching That Has Your Back — Upstream feeds fail. Servers crash temporarily. Feed-repeat caches source feeds locally, so these hiccups won't break your output. Your downstream subscribers get consistent feeds even when upstream sources are having a bad day.

Aggregate From Anywhere — Pull from multiple source feeds simultaneously, each with its own sampling rules. Maybe your technical feed combines industry news with your personal archive, with different rotation speeds for each.

Handles the Messy Formats — RSS 2.0, Atom, even good old RDF—feed-repeat processes them all without complaining about format differences.

Deployment That Fits Your Setup

This is where feed-repeat really shines for developers and operators. You can run it however fits your infrastructure:

NixOS — Full module integration means you define feed configurations directly in your NixOS setup. The module handles systemd services, permissions, and even Nginx configuration with optional SSL. Infrastructure-as-code perfection.

Standard Linux with Systemd — A traditional systemd service with timer support. Takes a few manual steps to configure users and directories, but the documentation covers everything clearly.

Docker — Quick container deployment from GitHub Container Registry. Mount your config and output directories, and you're live in seconds. The container runs as non-root, which is a thoughtful security detail.

GitHub Pages — Since output is static feed files, you can serve them from GitHub Pages or any static host. Perfect for creating curated "greatest hits" feeds at zero cost.

Who Gets Value From This?

Writers with deep archives — Your best content shouldn't disappear after a week. Give new subscribers the full picture of what you offer.

Feed curators — Building aggregated content streams? Keep them fresh and varied without manual work.

Haskell enthusiasts — Well-written functional code that's actually useful? Worth exploring for inspiration or contribution.

NixOS users — Declarative feed management integrated into your system configuration is genuinely elegant.

Ready to Try It?

Pre-built binaries cover both AMD64 and AArch64, so you don't need a Haskell environment to get started. For building from source, GHCup handles the toolchain installation painlessly.

Most people will find Docker the fastest route to running feeds—pull, mount, go.

What stands out about feed-repeat isn't just the concept. It's the execution: thoughtful weighting algorithms, resilient caching, flexible deployment, and NixOS integration that shows someone solved their own problem first and then made it accessible to others. That's how good open source gets made.

If you've been looking for a way to breathe new life into your content archive, this might be the tool you've been overlooking.

Find it at github.com/abhin4v/feed-repeat.