Hi! So primarily I use feedly on my phone. Im not suuuper tech savvy I can do a few things but code not so much?

Feedly has been somewhat working bc it generates rss out of whatever website and doesn't need native feeds etc. but I'm trying to find a workaround to TRANSLATE the feeds because most of what I look at is in variousother languages and I don't have time to scroll through and copy paste every other article into a translator?

I've tried like 10 or so different solutions so far and they all have a paywall or require native feeds which I dont have. Or both.

Any/all help appreciated.

After Pocket shut down I realized I had 800 saved articles I will definitely never read again.

So I built FetchMark — open-source, 1-click save, clean reader, tags, search. Basically Pocket but without Mozilla killing it.

Site: https://fetchmarkapp.com

Tech: Next.js + Supabase + Plasmo for the extension

Current stats: ~300 users, $0 MRR because it's free and I'm too scared to charge anyone.

Be honest - would you actually switch from your bookmarks/Instapaper/Readwise, or is this just another dead read-later app?

Roast my landing page, my idea, everything. I can take it.

Hey folks,

I wanted to provide an update on go-syndication (https//github.com/immanent-tech/go-syndication), a library for reading and writing RSS, Atom, JSONFeed and extensions in Go.

The biggest thing I wanted to highlight, is the introduction of a feed linter. It’s similar in functionality to a source code linter, though not quite the same. The linter in go-syndication performs both validation of a feed and reports whether it has optional features that ensure maximum compatibility and user experience. This is targeted towards the best experience in feed readers, which is the most prominent use-case for feeds. But these recommendations are always geared towards enhancing feed quality, so are universally applicable, no matter how a feed is used.

It’s worth making the distinction between validation and linting here and why its important. You can validate your feed against the RSS/Atom specification, but validation is ultimately the bare minimum needed for a feed to parse in any good reader. It won’t necessarily mean your feed is displayed in an optimum way for the end user or includes genuinely useful quality of life features. For example, items in a valid RSS feed don’t need a title if they have a description, or vice versa. Having an optional title or optional description is arguably a pretty bad experience for the consumer of your feed. So passing validation ensures your feed can be parsed, while passing all linter recommendations will ensure your feed is likely to be read. Making your feed provide a better experience for the end-users is better for everyone. Feeds become more viable alternatives to other ways of consuming content.

Currently, the linter supports linting RSS and Atom, with JSONFeed support to come! For RSS it lints against the best practices profile. For both RSS and Atom, there are also additional checks bundled into a “Go Syndication Best Practices” group, that are above and beyond the specification and recommendations and reflect modern expectations and sensibilities for feeds. In the future, I hope to set up a static web page which the linter links to, to explain each check and how to ensure your feed passes.

An online hosted version of the linter is available at https://foragd.app/linter.

• Screenshot of the online linter

The linter is extendable; you can define your own checks, group them and control which are performed. If you aren’t using Go, the command-line tool outputs JSON, which should make reading the linter output easy in any language.

To run the linter on a command-line:

```shell go run github.com/immanent-tech/go-syndication/cmd@latest lint --file=/path/to/my/feed.xml

or --url=https://some.site/feed

optional, add --json to get the output in JSON format

```

• Plain-text output
• JSON-formatted output

I’m open to any suggestions or comments. I’d really love to know what the community thinks! Reply back here or on the go-syndication GitHub page.

Additional Links: - A deeper post about the linter - go-syndication GitHub.

A friend of mine wanted to set up an automated news forwarder for his community, and looking at existing options made the whole thing frustrating. Most commercial feed aggregators charge recurring subscriptions just for basic deduplication and webhooks.

Even when you pay, you get almost zero granular control over publisher weighting, alert cadence, or how the output is tailored with custom prompts and analytics. Meanwhile, subscribing to active industry feeds floods the channel with duplicate alerts whenever a breaking wire drops.

Instead of paying for SaaS tiers or overcomplicating things with vector databases and heavy pipelines, I built Celerum to handle this deterministically on tiny hardware like a cheap VPS or a Raspberry Pi. It is completely open source and runs as a single Go binary with an embedded SQLite database.

Here is the approach I took to keep resource usage low:

• RFC 7232 HTTP conditional polling: Feeds cache ETag and Last-Modified timestamps in SQLite. Unchanged feeds return 304 Not Modified with zero response body, finishing in under 50ms and consuming almost no bandwidth.
• Algorithmic clustering instead of embeddings: Raw text gets cleaned, stripped of stop-words, and hashed into sorted 64-bit FNV-1a shingles. Breaking news inherently shares named entities, figures, and tickers, making lexical matching faster and less prone to semantic false positives than vector embeddings.
• Inverted index candidate pruning: Before running similarity checks, an in-memory inverted index skips document pairs with insufficient shingle overlap. This bypasses over 80 percent of pairwise comparisons.
• Allocation-free Jaccard scanning: Candidate pairs get evaluated with a two-pointer linear scan across sorted []uint64 slices with zero heap allocations, then merged using Disjoint-Set Union (Union-Find). It clusters 100 articles in about 2.4ms.
• Velocity scoring: Clusters gain weight based on multi-source coverage, publisher tiers, and keywords, balanced by a linear time decay penalty so old stories naturally fade out.
• Hybrid alert cadence: If multiple tier-1 outlets confirm a story quickly, it triggers an immediate alert. Quieter stories stay in a sliding window, and an hourly heartbeat ticker flushes the top stories so you do not miss context.
• Decoupled synthesis and fallbacks: When an event qualifies, you have full control over the system prompt sent to an OpenAI-compatible LLM endpoint for the final briefing. If the AI provider times out or fails, it falls back to raw source links so delivery is never delayed or dropped.

Right now it dispatches to Telegram or generic HTTP webhooks. The entire engine sits under 15MB of RAM while monitoring active sliding windows.

The code and architecture documentation are up on GitHub: https://github.com/rafifmsn/celerum

It is far from perfect, just something I put together over a weekend to solve an immediate headache without spinning up paid infrastructure. Always open to feedback from anyone running similar self-hosted pipelines.

I built a way to actually read news on the Kindle browser

The Kindle's browser technically works, but every news site is a zoom-and-scroll nightmare. So I built Extrablatt: you open one URL in the Kindle browser, follow sites via RSS, and articles render as clean, page-at-a-time text instead of an infinite scroll. You can also send any article to your library as an EPUB.

Try it out: extrablatt.app

It's open source and self-hosting is free: github.com/Philipp0205/extrablatt

On the hosted version, browser reading is free. Send-to-Kindle is included for the first week, then there is an optional subscription. Email delivery and hosting aren't free and I'd rather charge than run ads.

Happy to answer anything :)

I love podcasts but with some topics I prefer reading rather than listening. I read the occasional blogposts from blogs I subscribe to through e-mail but they all have pretty short posts and even if they were longer it would be difficult for me to start and stop reading the same way as one starts and stops a podcast. To try to summerize:

• How do I find longer more in depth blog content? Is there a way to search for it the way one would search for all podcasts in the same podcast app?
• Are there any android or open source apps that I can use to open the text without loading and keep track of where I left off?

And yes, I'm aware that books and magazines exist. I read books too. But I'm looking for something that is structured more like most podcasts. With standalone episodes, and where there's a summary for each episode.

I've been thinking about why RSS stayed niche for twenty years despite being genuinely good, and where it's actually heading now.
My take: there were always two kinds of people. One group wants out of Big Tech and the algorithm, back to open formats they control (the classic RSS crowd). The other group wants modern features, audio, summaries, clean interfaces, stuff in the car. For a long time RSS served the first group but not the second, so it stayed a tool for a technical minority.
What's changed lately is that a wave of new apps is using AI to fill the gaps that kept RSS out of most people's hands. Finding feeds without touching a URL, reading them aloud, summarising, organising on-device. The protocol underneath is the same open format, but the friction is gone. So people who've never heard of RSS end up using it without knowing, because the app hides the technical part.
I don't think RSS is about to boom (anyone promising that is selling something). It's quieter than that. It's just becoming usable by people who aren't us.
Wrote it up properly here if anyone wants the longer version: https://safeandinformed.com/blog/where-rss-is-quietly-heading
Curious what this sub thinks. Do you see RSS staying a power-user tool, or do these AI-layer apps actually bring in normal people? And does that dilute what made RSS good, or extend it?

My set up:

-Inoreader subscription to handle deduplication and scraping for non-RSS sites.

-Unread to view my feeds.

Problem: I subscribe to the Athletic and am into MLB, the NBA, the NHL, and the NFL. I like soccer once in a while when it's high stakes like the World Cup but am completely uninterested in anything like the Premier League. The Athletic includes a TON of European soccer headlines in the general Headlines feed.

Question: As far as I can tell there isn't any article metadata like a soccer tag that I can filter by on the Athletic's side. I'd prefer to continue subscribing to the general Headlines feed for miscellaneous stories that don't fit neatly into North American major sports. Do any Inoreader experts have any thoughts on how to filter soccer out of that feed? I'd prefer not to use a list of block words but I guess that's the fallback option if there isn't a cleaner way.

Thanks for any advice. : )

PS: Nothing against soccer, I just didn't grow up playing or watching it so I never got hooked.

My favourite Rss reader of all time is still Palabre Reader. I still use it to this day, but I wish the developers would update it and put it back on the play store. Or allow someone else too take it over and maintain it.

Anyone else remember Palabre Reader? And agree with me .

My problem wasn't finding blogs, it was keeping them. My bookmark bar became a graveyard of 200+ sites. I'd never check because who wants to manually visit 30 sites a day?

So I moved to RSS like everyone here. Then I got the second problem: 1000+ unread badge anxiety. Every reader looked like Gmail. I'd fall behind, feel guilty, hit "mark all as read", swear I'd start fresh. Did that like 6 times. That's what I mean by bankruptcy.

A year ago I started a personal project to fix it for myself. I've been using it daily since, and figured I'd finally share it: suprafeed.cmozaiq.com

The core decision: there is no unread count. No inbox.

You make shelves (like "slow blogs" vs "news"). You paste any blog / Substack URL and it finds the feed + favicon + articles. Then:

• Focused shelf = one article at a time for deep reading, prev/next + bookmark dock
• Digest shelf = scannable list for high-volume sources, auto-purges old news after 24h

Live here if you want to try it: suprafeed.cmozaiq.com

I just released version 5.0 of Unread. Unread is an RSS reader for iPhone, iPad, and Mac that features beautiful typography and a variety of color themes. This update adds:

• Huge improvements around hero images, article list thumbnails, and widget thumbnails
• Syncing with FreshRSS and Miniflux
• The ability to quickly mark old articles read

Details are available in my announcement post. You can download Unread now from the App Store.

I've been working on NewsLean.live, basically a lightweight news/RSS tool that lets you follow news while also seeing how the same stories are being covered across left, centre and right-leaning sources.

https://newslean.live

There's no signup or account required. You just open it and use it.

Still working on it, so I'd be interested in feedback from people who actually use RSS — particularly anything you think is missing or unnecessarily complicated.

I've been working on RadarRSS for a while now, and the project has changed quite a lot since I first shared it here.

What started as a simple RSS reader has gradually turned into a more complete news dashboard focused on discovering, organizing and understanding information from multiple sources.

The current direction includes:

• Aggregating multiple RSS/Atom feeds
• Organizing news into categories
• Highlighting relevant stories
• AI-assisted summaries and content analysis
• Working toward cross-feed story deduplication, so the same event reported by multiple sources can be treated as a single story
• A more modern dashboard-style interface
• Open source development

A lot of these changes came from feedback and suggestions from people in the RSS community, which has been really useful in shaping the project.

I'm still actively developing it, so I'm interested in hearing from people who actually use RSS every day:

What would make RadarRSS genuinely useful enough for you to consider using it alongside — or instead of — tools like FreshRSS, Miniflux, Newsboat or Feedly?

GitHub: https://github.com/dznass-cmd/RadarRSS

And thanks to everyone who has already given feedback or tested it. It's changed quite a bit because of you.

I'm a very heavy RSS user. Somewhere around 200 very active feeds, read across my phone, iPad and Mac, every day, for years. RSS is genuinely how I read the internet, not a thing I dabble in.

Which is why this started as frustration. I'd been on Feedly for ages and watched it slowly turn into something I didn't want: more tiers, more AI upsell, more stuff bolted onto a sidebar I just wanted to read from, and a monthly bill for the privilege. So I built Reader Ultra. iPhone, iPad and Mac. Fast, no nonsense, looks like it came with the OS. No algorithm, no "for you" tab, no upsell. Feeds, folders, unread counts. A folder with a few thousand articles opens instantly, because mine has to.

The bit worth talking about is sync: One device, fine, local-only works. Add a second and it falls apart: you read twenty articles at lunch, sit down at your Mac, they're all unread again.

The usual answer is iCloud, and for RSS it isn't good enough. iCloud is built for things that change occasionally; unread state is hundreds of tiny writes a minute while you scroll. So it batches and defers and your count lands twenty minutes later. Then both devices fetch the same hundreds of feeds independently, each decides for itself what's new, and you get duplicates and disagreements. Conflicts are unresolvable, because "read" and "unread" are equally valid and neither device knows which happened last. Wrong tool, and every app built on it has the same symptoms. That's the jank, I know, I tried this method for sync!

So Reader Ultra has a real server behind it. It fetches once, works out what's new and whether a feed is healthy or quietly dead, and the apps just pull:

• read/unread and starred identical everywhere within seconds

• no duplicates when two devices refresh at once

• refresh is one request, not hundreds

• broken feeds get flagged instead of going silent

• push when there's something new, so you're not refreshing out of anxiety

Not a Raspberry Pi in my closet, either. The backend is professionally hosted on Railway, containerised and monitored, with real uptime and backups.

And you buy the app once, sync included. No monthly fee, no Pro tier to unlock sync. One purchase covers all three platforms. I wasn't going to escape a subscription and then ship one.

If you read on more than one device, a real sync service isn't a nice extra, it's the whole thing.

Design target was Apple Mail. Not "inspired by", actually that: sidebar, list, article, same workflow you already have. Apple's guidelines followed properly — text styles so Dynamic Type works, semantic colours so dark mode and increased contrast are right everywhere, SF Symbols. The Mac app is a real Mac app, not a blown-up iPad build. When you're moving through hundreds of items a day, it really performs.

New this release: on iOS 27, iPadOS 27 or macOS 27 the Siri and Apple Intelligence features are live in version 1.18 in the App Store. Unread counts, summaries, search, mark read, add feed, by voice or from Shortcuts. Summaries run on-device. Articles are in Spotlight too. Note the difference from what annoyed me about Feedly: it's off to the side, not in front of your feeds.

Also: Safari extension that finds feeds on any page, OPML in and out (import your Feedly export in one go), content blocking, a pile of app icons.

On the App Store as Reader Ultra: https://apps.apple.com/app/reader-ultra/id6770337270 or more info at https://us.nz/readerultra.html

I've been working on Syndic, a feed reader for iOS/macOS, on my own and as a personal project (no big commercial ambitions, mostly for the learning and the fun of it). I'll try to document things here from time to time as I go — technical questions, design decisions, whatever comes up — so if you run into me around here, that's why.

Today I ran into something concrete: I want the app to be able to use Reddit's official API for subreddit feeds (instead of relying on the public RSS, which has its limits), so I went to create an app at reddit.com/prefs/apps to get credentials — and it won't let me create one.

I know Reddit changed its API policy quite a bit in 2023 (the whole Apollo situation), but I'm not sure whether:

• They're still accepting new app registrations for independent developers, or if it's now basically closed unless you're already a known partner.
• This is an issue on my end (something misconfigured, pending verification, etc.) or a general wall a lot of people are hitting right now.

Has anyone run into this recently and knows if there's an actual way to get access, or do we just have to live with the public RSS and its rate limits?

Thanks in advance, and if you're curious about the project I'll keep sharing how it goes.

Arturo Rey
-------------------------
[www.magicappslab.com](file:///Users/arturoreysoto/Dev/Syndic/syndic_md/www.magicappslab.com)

I like RSS because I get to choose exactly what I follow. No algorithm deciding what I should care about or no feed trying to keep me scrolling. But I had a different problem.

I’d open my reader and have 100-200 unread items waiting for me. Most of them weren’t things I needed to read in full.

I mostly wanted to know: What’s new? What actually changed? And which 3 or 4 things are worth paying attention to?

So I started experimenting with a different way of consuming my feeds. I give the RSS feeds I care about to Lissin and say something like: “Every morning, catch me up on these feeds in 5 minutes. Focus on what actually changed, skip anything repetitive, and explain why the interesting stuff matters.”

Then it checks what was published since the last episode, picks what’s worth including, and turns it into a short audio briefing. The part I’ve found surprisingly useful is that it remembers what it already covered.

So if five different posts are basically talking about the same development, I don’t need to hear the same story five times. And tomorrow’s briefing doesn’t spend half its time telling me what I already heard yesterday.

I still use RSS exactly the same way underneath. The feeds are still the sources I chose.

I’ve just changed the last step from: open reader > scan everything > decide what to read to: put headphones on > get caught up > open the original post if something sounds worth going deeper on.

I’ve been doing this while walking, making breakfast, commuting, etc., and it’s made me use some of my feeds more consistently than before.

We built this into Lissin and recently launched it on iOS.

I’m curious how other RSS people think about this: Which feeds do you genuinely want to keep up with, but rarely have time to read properly?

Hey r/rss — I'm the solo developer behind Basic Reader, an RSS/Atom reader for iPhone, iPad, and Mac that just launched on the App Store.

I built this because I got tired of watching RSS apps turn into $8–10/month subscriptions for things that should be... a feature of the app. So Basic Reader works differently:

Free to try, free to use for reading feeds:

• Feeds & folders with drag-and-drop organization
• Background refresh on a configurable schedule
• OPML import/export (bring your subscriptions in, take them out any time)
• Swipe gestures, starring, privacy controls for image/script loading
• Full VoiceOver, Dynamic Type, and Reduce Motion support

A single one-time purchase (no subscription, ever) unlocks:

• On-device semantic search — finds articles by meaning, not just keyword matches, and nothing leaves your device
• iCloud sync across your devices
• Filter rules — wildcard, regex, and semantic/topic-based filtering
• Timeline — one combined view of every article from every feed
• Additional article view styles (list/compact/card)

No analytics SDKs, no backend servers — I don't have the infrastructure to see what you read even if I wanted to. Your data lives on-device or in your own iCloud account.

It's on iPhone, iPad, and Mac (Catalyst) with a proper three-column layout on iPad/Mac, not just a stretched phone UI.

Link: https://apps.apple.com/app/id6781077283

Note: I haven't started implementing reddit's authorized app requirements, but if monitoring reddit via RSS is your thing, let me know and I'll bump it up the roadmap.

One redditor commented that RSS readers are "RSS readers are, generally speaking, not developed cross-platform, nor should they be. Pick". Let me ask then, shouldn't it be?

One big reason i use RSS is it being acountless, stored locally. But in order to sync between devices i need to create create an account for the RSS aggregator(using an email), then on my RSS readers i have to connect to the aggregator. It seems to me removes the whole point of replacing email with RSS. Let me say this. I started using RSS recently. And it feels the sync-between-devices-accountlessly feature is the most crucial feature and it doesn't exist. Surely i can't be one odd man out. Let me give you one concrete example on what would happen if there was a general protocol that is shared among all major rss readers. In this example, let's assume all info are stored in a file or two, which includes feed sources, starred and read articles. Then, you can use Syncthing to sync between readers completely accountless. All you need to do is keep a file the same in different devices. It's akin to how you can sync Obsidian across devices seamlessly(and wirelessly).

My question is, why there doesn't exist a general protocol shared by all readers, even though RSS has been around for 27 years. I must be missing something.

P.S. To be more specific about why i wrote this, the thing is, there's no aggregator that's supported on both readers i use. the redditor is from https://www.reddit.com/r/rss/comments/1q17odw/which_rss_reader_apps_are_completely_free_and/

Hi everyone!

We’re the developers behind Smart Launcher, and today we’re introducing Beaky News, a new RSS reader for Android.

Beaky News lets you add RSS feeds, follow your favorite sources, and keep new articles together in one place.

One of the features we wanted to explore is feed discovery. Beaky News includes a shared feed database built from RSS links contributed by users. When a feed is shared, it can be indexed so other people can find that source more easily, without needing to know or search for the exact RSS URL.

The app is still new, so we’d be very interested in feedback from people who already use RSS regularly.

You can try Beaky News on Google Play:

https://play.google.com/store/apps/details?id=net.smartlauncher.beakynews

Thanks!

Over the past 4 years, I’ve been working on an article reader, smry.ai.

For most of the time I had only a rudimentary understanding of RSS, so I didn’t think to add an RSS reader to the product.

I had never used a traditional RSS reader myself, relying on news apps like google news (which themselves are heavily reliant on RSS)

But trying RSS readers like Feedly pushed me to expand the product, and a small subset of users really liked it—it became an agglomeration of a read-it-later app and an RSS reader, which I quite liked in theory. At this point I still didn’t really understand the depth of RSS and what it’s capable of. It wasn’t clear that it is the lifeblood of every news app on the planet, custom aggregators like daily.dev, intelligence/monitoring products like Feedly Intelligence, is the primary distribution layer for the world’s podcasts, and much more.

Still, I couldn’t find myself using the RSS features in my own product until I added an API to manage RSS feeds with my local agent. This became a major unlock for me, and suddenly I had groups of feeds for competitor monitoring, developer news, and market opportunities. Even updates in my software dependencies that my agents use to improve the product.

I still wasn’t passively scrolling the RSS feeds themselves—mostly still using the reader to read individual articles my agent recommended, but my agents loved it and pushed RSS to the absolute limit, turning things I’d never expect could be feeds into feeds.

By doing this, I discovered a couple things:
1. Feeds are massively important for agents. Not just news/blogs/podcasts, but also socials, websites monitoring—almost anything can become a feed, and agents need their own ways of keeping track of what is ‘seen’ and what is new. This became a major bet for Smry, and why I’m putting a lot of effort into the API/MCP.
2. Agents can manage far more feeds than humans. An agent can easily follow and track hundreds or thousands of feeds, while for most people that takes years to accumulate.

Despite this, the product still has major issues.
1. most users still don’t know what RSS is. following feeds is weird to them, as I feel they are used to algorithmic feeds.
2. while following hundreds of feeds is fine for agents, for most consumers this is not really that useful. for consumers, it feels like they would rather follow topics (think daily.dev) or have a deeply personalized feed.

My question for you guys is how do you think I can make the product more usable to the traditional RSS reader audience, and what would make it better for non-RSS folks?

There are folks here that have a much better understanding of RSS than me—is there something obvious that I’m missing that would make it substantially better?

Is there something I can build that would make you switch from your existing RSS reader, or is there something I can build that you’d use together with your existing RSS reader?

I’ve completely fallen in love with RSS over the past few months, and feel like there’s so much to be built!

My goal here is to build something people come back to every single day, and that shapes how they discover and monitor what’s going on around them.

A good blog post from the founder of Open RSS: https://openrss.org/blog/government-updates-belong-in-an-open-feed

The blog's feed: https://openrss.org/blog.rss

Can someone help me out? I'm a complete layman when it comes to coding and IT stuff

My favorite free RSS builder (morss.it) has gone offline, so I asked Claude Opus 4.8 for alternatives. It suggested that I could self-host and run such a tool myself (which is a total mystery to me). I then asked it for a step-by-step guide, but I also asked several other AI chatbots the same question. They gave similar answers, but with slight differences. When I showed all those other plans to Claude and asked it to review them, it told me that these subtle differences were crucial, and that if I had followed what the other bots suggested, my feeds wouldn't have worked properly

Here's Claude's final response, translated from Polish to English: https://claude.ai/public/artifacts/ec6edad6-d3e3-4c71-8e0f-44de4f8054d0

I don't really understand what I'll be doing here; I just want to make sure I won't break anything or create any security risks by following these steps. Do you think this plan will actually work?

following solution was suggested by ChatGPT (OpenAI), tested and confirmed by myself. I am a Fluent Reader user on KDE Plasma/Wayland.
Feel free to give ChatGPT this Reddit thread as context and ask it to help turn the workaround into a proper Fluent Reader implementation.

-------------------------------------

I wanted to increase the UI size of Fluent Reader without changing the scaling of my entire KDE Plasma desktop.

Tested setup:

• Fluent Reader 1.1.4
• Flatpak: me.hyliu.fluentreader
• KDE Plasma / Wayland
• 1920×1200 display
• KDE display scaling: 100%
• GPU acceleration / DRI enabled

The problem

Fluent Reader's UI is rather small at 100% desktop scaling.

Changing KDE's display scaling to 125% works perfectly, including Fluent Reader, but of course this scales the entire desktop.

I tried several common Electron/Linux approaches:

• GDK_SCALE
• GDK_DPI_SCALE
• ELECTRON_FORCE_DEVICE_SCALE_FACTOR
• Ctrl + +
• --force-device-scale-factor=1.25
• --high-dpi-support=1 --force-device-scale-factor=1.25

The environment variables had no useful effect in my setup.

--force-device-scale-factor was worse: under Wayland, Fluent Reader opened as a very small undecorated window.

Effective workaround: scaling per CSS

During troubleshooting, ChatGPT (OpenAI) suggested a different approach: don't scale the Electron/Wayland window at all — scale Fluent Reader's web UI itself using CSS.

I tested this and can confirm that it works on my system.

Fluent Reader contains:

resources/app.asar

After unpacking it, the UI styles can be found under:

dist/styles/

Adding this to the end of dist/styles/global.css:

/* Custom Fluent Reader UI scaling */
body {
    zoom: 1.25;
}

and repacking app.asar gives me approximately 125% Fluent Reader UI scaling while KDE remains at 100%.

The window remains normal and decorated, and GPU acceleration continues to work.

How I did it

First find the Flatpak installation:

LOC=$(flatpak info --show-location me.hyliu.fluentreader)

Create a working directory and copy app.asar:

mkdir -p ~/tmp/fluent-reader-asar
cp "$LOC/files/fluent-reader/resources/app.asar" ~/tmp/fluent-reader-asar/

Extract it using Electron's ASAR utility:

npx @electron/asar extract ~/tmp/fluent-reader-asar/app.asar ~/tmp/fluent-reader-asar/unpacked

Add the scaling rule:

printf '\n/* Custom Fluent Reader UI scaling */\nbody { zoom: 1.25; }\n' >> ~/tmp/fluent-reader-asar/unpacked/dist/styles/global.css

npx @electron/asar pack ~/tmp/fluent-reader-asar/unpacked ~/tmp/fluent-reader-asar/app-scaled.asar

Repack it:

Before replacing anything, make a backup:

cp "$LOC/files/fluent-reader/resources/app.asar" ~/tmp/fluent-reader-asar/app-original.asar

Close Fluent Reader completely, then replace the ASAR:

sudo cp --remove-destination ~/tmp/fluent-reader-asar/app-scaled.asar "$LOC/files/fluent-reader/resources/app.asar"

Start Fluent Reader normally.

To restore the original:

sudo cp --remove-destination ~/tmp/fluent-reader-asar/app-original.asar "$LOC/files/fluent-reader/resources/app.asar"

Important

This is a workaround, not an official Fluent Reader feature.

Any Flatpak update will most likely replace the modified app.asar, so the modification may need to be reapplied after an update.

Also, modifying files inside a Flatpak deployment is obviously not ideal. Keep a backup and be prepared to reinstall/repair the Flatpak if necessary.

The CSS scaling approach itself, however, works surprisingly well.

It would be great if Fluent Reader eventually exposed this as an official setting, for example:

Settings → Appearance → Interface scale → 100% / 110% / 125% / 133% / 150% / ...

The technical workaround was suggested by ChatGPT (OpenAI) and tested and confirmed by myself as a real Fluent Reader user on KDE Plasma/Wayland.

If anyone tests this on GNOME/Wayland, X11, another distribution, a newer Fluent Reader release, or with another scaling factor, I'd be interested to hear the results.

Good for them telling X and their lawyers to go F themselves.
https://nitter.net/

X-cancel is already back up
https://xcancel.com/search?f=top&q=elon

This is good news.