Is RSS making a comeback; tutorial adding support

RSS, which stands for Really Simple Syndication, is a format and standard for web syndication. Created in March of 1999 by Engineers at Netscape, it provided a convenient way for 'web surfers' to receive updates from many different sources without having to visit each individually.

Is RSS making a comeback?#

You can imagine the optimism at the time, the Internet was a burgeoning space. The edges and corners weren't well defined, like they are now. RSS soared in popularity as more people 'came online', to this new exciting environment. Support, as we'll see below, is simple to add and provides yet another way to distribute content simply across the web. Users retain control of the information they see. Subscribing to a feed/channel (both terms are used interchangeably) provides a mechanism in which content is served to users when a new post is made. Like an early version of a notification, but instead of a remote server deciding when/if you receive it, your tool of choice fetches it in a regular interval.

Google Trends shows that the search term "RSS" peaked in 2006 and has been in a steep, then slow decline ever since. Google Reader, which became the most popular RSS feed aggregator followed this trajectory. It was released in 2005, seems to have peaked sometime between 2008-2010¹, and ultimately closed in 2013 due to a decrease in users² (and a push for Google+ usage). With the rise of Social Media options over the later 2000s and early 2010s it seems RSS fell by the wayside. Interestingly though, there's a new peak in Google Trends that's formed as of 2026. Perhaps that's due to algorithm fatigue and the rising trend of digital detoxes³.

The Internet has become a place where there are only "five giant websites filled with screenshots of the other four" - Cory Doctorow. Ever since the introduction of an algorithmic feed, the Internet has changed shape. More often than ever, you're pushed content which produces the most engagement and ultimately, revenue for the company in question. Rather, than the content you may like to see. This blasé attitude, continual scandals, along with a lack of regulation or willingness to meaningly moderate content has resulted in countries beginning to crack down. We're now seeing global interest in social media bans⁴ for the youth. Which is most likely the beginning of anti 'big tech' regulation.

Contrasting to contemporary social media, RSS feeds aren't algorithmic⁵. They're content from the source. For example, NPR provides RSS feeds across all categories of content they produce. Take a look at their "news" RSS feed. It's simple. No invisible hand of the algorithm deciding whether it's served to all 'subscribed' users, or just a handful. Many news organisations and blog posting platforms still provide RSS feeds which you can subscribe to, such as the BBC, and Medium (which create one per account by default, I have one it turns out). Many RSS tools allow you to mix different feeds into a new one, utilising automation, rules, filters and more to create a flow of information as you describe. In a sense, you can create your own algorithm. With transparency over what is served and why, if it's not to your liking you can always tinker and change.

With the Internet continuing to be closed in upon, perhaps technologies like RSS are the answer. It was already popular once and the infrastructure is there. Maybe that's why we can see a spike of searches in 2026?

Using RSS#

When I say the infrastructure for RSS is here, it really is. There are so many services and tools which provide a UI and aggregation for feeds. Regardless of your constraints, there are a multitude of options. Whether you'd like to use a centralised service (read third party website which needs an account), self host it, or are wanting to keep it simple with just a web extension. All are options, and are listed below.

Some things to note before we dig into different tool options:

• RSS is just a data specification.
  • The actual 'fetch' for RSS feed items is handled by your tool of choice.
  • Most tools provide options to change how frequently feeds are queried for updates (i.e every 5-10m), as well as manual execution.
• Subscribing and unsubscribing from feeds is trivial.
  • When you subscribe, all you're doing is giving your tool of choice a webpage to query data from in it's next scan.
  • Unsubscribing just deletes the webpage from storage which stops querying for it.
• You don't have to provide any sensitive or personal information, like an email address, first name, last name, or password.
  • Centralised tools require accounts for use, but the self hosted and web extension options don't.
  • Not having to provide sensitive data means there isn't a third party or walled garden you're having to trust with security.
    • Nor can you become a target due to your data being sold, or exposed during a hack. Since there is no data being exchanged!

Centralised#

Some of the most popular centralised RSS services are:

• Feedly
• NewsBlur
• Inoreader

All are free to use, but offer paid plans that remove the limitations of the free tier. Interestingly they all have marketing copy which focus on user control. Inoreader's home page boast "Build your own newsfeed". Newsblur has this as subtitle/tag line "A personal news reader bringing people together to talk about the world", along with "A new sound of an old instrument" harkoning back to RSS's previous dominance. Lastly, Feedly features this title on their 'News Reader' RSS product "Take control of your news feed".

The focus on user control makes a lot of sense. RSS as a tech turns you into a curator, rather than a passive consumer of an algorithm. However, as a result there is a higher burden placed on yourself as you have to make executive decisions as to what feeds/channels to subscribe to. Each of these centralised tools offer an ease-in to the tech as they each provide a search tool to find more feeds to subscribe to. As well as the ability to sync your subscriptions across devices and platforms, such as Desktop and Mobile.

It's worth mentioning that Feedspot also provides a free to use search tool for finding RSS feeds.

Self hosted (and open sourced)#

The options in this category are vast, there's an entire section within the awesome-selfhosted repo. I've picked just the following two to talk about:

• FreshRSS
• MiniFlux

Each of these tools provide an entire application which you can run. Frontend, backend, and database. You are in full control of it running and as a consequence, your data and security.

As with any open source projects, there is a mix and match of features on offer. All of course handle subscribing to feeds along with a UI to consume feed items through. Both FreshRSS and MiniFlux have been actively developed for over a decade, with a still committed contributor user base. FreshRSS provides deeper customisation via extensions, whilst MiniFlux is more opinionated and boasts a wider set of features out of the box.

Web extensions#

This option has the lowest barrier of entry, not requiring an account or hosting to be sorted ahead of use. Here are some options:

• Feeder
• Feedbro
• EasyRSS

Note: Firefox links (they're also on Chrome).#

Each provide a popup window when clicked which shows unread feed items from your subscriptions. Along with a tab view (a dedicated webpage), for more involved actions such as managing your feed subscriptions and changing settings.

EasyRSS does exactly what it says on the tin. It's minimal, but not lacking. Very intuitive and straightforward to use, with only a few config options to play around with. The tab view shows an overview of your feeds, settings for fetching updates for them, along with sync, import, and export options. This is the easiest option to get started with. A bonus is that it's open sourced and hosted via Github. However, it also hasn't received any updates in 6 years. Can confirm that as of writing it still works though!

Feeder provides the best looking UI and the largest feature set, including syncing your feed across devices and platforms like others in the centralised category. It is free to use, as account creation is optional. But, paid plans unlock more features. The popup view shows each of your RSS feeds, your favourites, and any that are unread. The tab view is where it pushes the envelope, however, almost all of the features are locked behind a paywall. Filtering, rules, automation, and dashboard creation are all paid experiences.

Feedbro is somewhere in-between the previous two. It has the most aged UI while also providing more features than EasyRSS, without requiring an account or having a paid version like Feeder. The popup view shows unread feed items as well as a 'Find feeds in current tab' option, which seemingly scrapes the tab for RSS links. Pretty handy if you can't quite find it yourself, or can't be bothered to. The tab view provides folder customisation, where you're able to mash multiple different feeds into one, as well as a few different feed view options.

TheFarrelly now supports RSS#

I've added support for my posts in RSS format. Which was both extremely simple and straightforward. There's a node based RSS library which can turn Javascript objects into a rss.xml file for you. With the heavy lifting done, all you need to do is create a script to get your content metadata converted into xml. Then include it in your build step.

Tutorial, how to add RSS support#

1. Install the rss lib, pnpm add rss @types/rss --save-dev .
2. Create a node script which will generate your rss.xml from your content metadata.
   • Here's an excerpt from the script I wrote for this website,

   const generateRssFeed = () => {
     const feed = new RSS({
       title: 'TheFarrelly.com posts',
       description: 'Software engineering articles and thoughts from TheFarrelly',
       feed_url: `${BASE_URL}posts/rss.xml`,
       site_url: BASE_URL,
       language: 'en',
       pubDate: new Date().toUTCString(),
     });
   
     // grabs my posts & returns an array of objects with a title, desc, date, and url.
     const posts = getPosts();
   
     // chucks my posts into the RSS feed object
     posts.forEach(post => {
       feed.item({
         title: post.title,
         description: post.description,
         url: post.url,
         date: post.date,
       });
     });
   
     const rssXml = feed.xml({indent: true});
   
     // ensures that the posts dir exists within the public dir, so I can serve the rss via public/posts/rss.xml aka "/posts/res.xml".
     const outputDir = path.join(process.cwd(), 'public', 'posts');
     if (!fs.existsSync(outputDir)) {
       fs.mkdirSync(outputDir, {recursive: true});
     }
   
     const outputPath = path.join(outputDir, 'rss.xml');
     fs.writeFileSync(outputPath, rssXml, 'utf8');
   
     console.log(`Success!\nrss.xml generated at ${outputPath}`);
   };
   
   try {
     generateRssFeed();
   } catch (error) {
     console.error('Failed to generate RSS feed:', error);
     process.exit(1);
   }
   

3. Add a call to this script within your package.json, i.e pnpm generate-rss.
   • Call this before you generate a build, I've added mine into a 'pre' build script.
4. Add a link block to the rss.xml file, e.g.

   <link
       rel="alternate"
       type="application/rss+xml"
       title="TheFarrelly.com posts"
       href={`${BASE_URL}posts/rss.xml`}
     />
   

   • Now RSS readers can easily find it & subscribe.

That's it! You've added RSS support to your website.

Whenever I create a build of this website, a rss.xml file is generated at /posts/rss.xml. If I make a new post any consuming RSS feed tool would then be able to fetch it, and display the new post.

Note: What's CDATA?#

You may notice in your generated rss.xml file that there's this seemingly random CDATA keyword wrapping text. Here's an excerpt of my rss.xml to illustrate

<channel>
<title><![CDATA[TheFarrelly.com posts]]></title>
<description><![CDATA[Software engineering articles and thoughts from TheFarrelly]]></description>
<link>https://www.thefarrelly.com/</link>
<generator>RSS for Node</generator>
<lastBuildDate>Wed, 01 Apr 2026 15:32:44 GMT</lastBuildDate>
<atom:link href="https://www.thefarrelly.com/posts/rss.xml" rel="self" type="application/rss+xml"/>
<pubDate>Wed, 01 Apr 2026 15:32:44 GMT</pubDate>
<language><![CDATA[en]]></language>
<item>
    <title><![CDATA[Nodemailer and Fastmail tutorial]]></title>
    <description><![CDATA[Turns out sending emails is really, really, easy.]]></description>
    <link>https://www.thefarrelly.com/posts/nodemailer-and-fastmail-tutorial/</link>
    <guid isPermaLink="true">https://www.thefarrelly.com/posts/nodemailer-and-fastmail-tutorial/</guid>
    <pubDate>Wed, 25 Mar 2026 00:00:00 GMT</pubDate>
</item>
...
</channel

Turns out CDATA, which stands for Character Data, is part of the XML spec,

they [CDATA] are used to escape blocks of text containing characters which would otherwise be recognized as markup.

XML has special characters such as angle brackets (>,<), ampersand (&), and quote delimiters (',"). Which if used in text would conflict with XML parsing. Wrapping that same text with CDATA will escape it and ensure it's treated just as text. Nice!

Note: But XML looks ugly#

You're in luck. XML actually has a stylesheet you can apply to it, called XSL (these files have the .xsl file extension). You can mix and match CSS via XSL. To do so all you need to add in your xml file is

<?xml-stylesheet href="/posts/rss.xsl" type="text/xsl"?>

where the href is the path to your soon to be created .xsl file. Which could look like this,

		...
		<style type="text/css">
			.posts {
	            background: white;
	            border-radius: 8px;
	            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
	            overflow: hidden;
	        }
	        ...
		</style>
		...
          <div class="posts">
            <h2>Recent Posts</h2>
            <xsl:for-each select="/rss/channel/item">
              <div class="post-item">
                <h3>
                  <a>
                    <xsl:attribute name="href">
                      <xsl:value-of select="link"/>
                    </xsl:attribute>
                    <xsl:value-of select="title"/>
                  </a>
                </h3>
                <div class="post-date">
                  <xsl:value-of select="pubDate"/>
                </div>
                <p class="post-description">
                  <xsl:value-of select="description"/>
                </p>
              </div>
            </xsl:for-each>
          </div>

It provides the ability to use HTML elements and reference XML values like variables. In my script I create feed items that include a title, description, and link. The excerpt here references them within an HTML structure. CSS can be used either via the style element (as above), or imported from a .css file.

I think XML is fine as it is, but if you disagree, you do have options.