tjansen.de
Tim's stream of consciousness · JSON Feed
- I registered bigwide.net as home for my rss.chat + RSSmention + socialspec publishing system.
- In my previous entry about RSSmention, I had a lot of thoughts about authentication and signing entries. I don't think it is needed because a site can only prove that a comment existed with the help of a third party. And if such a third party is involved, it's much easier to let that external service do the validation by just requesting the comment and checking whether it is there. Maybe even signing the original comment. That way, the client does not need any keys at all.
Claude Opus 5.5 is simply amazing. Claude wrote podcast support for Downread, and it was incredibly simple.
First, I created a design with Claude Design, based on the basic ideas I had about where to display podcasts in the background, etc. It delivered an almost perfect design on the first try.
Then I gave the new design and my original description to Claude Code, and it created a fully working podcast subsystem according to my specs. It wasn't perfect - I have been spending pretty much all night improving and fixing subtle issues in the UI. But the technical parts were all perfect.
RSSMention
I mentioned before that I have a concept that allows sending comments to RSS posts without the need to authenticate with the host. Instead, you authenticate with the DNS domain and the web server you run on it. It's very similar to webmention, but for RSS instead of the web.
The following (raw) bullet points are from an email I wrote describe the current state:
RSSMention
- webmention doesn't really work for feeds. It's meant for a link from one webpage to another, not from one feed to another.
- Having a webpage for each user comment is not practical. There are people writing 1000s or even 10000s of comments every year. Managing them on a static webserver won't work, and I don't want users to need dynamic webpages.
- Having comments stored in RSS feeds is more doable. You can put 100 or so in a single file, and there are fewer reasons to regenerate the RSS file.
- The mechanics of webmention are perfect, but feed comments need to be from one permalink to another permalink, not from page to page. The comment's source feed must either be specified separately or included in the permalink (like <feed-url>#<comment-number>). So it probably shouldn't be called webmention. In my notes, I called it RSSMention.
Authenticity
- Another consideration is authenticity. Basic authentication of a comment can be established by checking whether the comment is also on on the user's comment feed, which should be available to the RSSMention server (either in the permalink, or submitted in a separate field).
- But a feed could make up a comment that I never wrote, or modify my comment without my permission. I can only prove that the comment is not on my website right now, but I can't prove that I have never written that comment - I could have deleted or modified it.
- Without establishing authenticity, there are all kinds of legal problems. People could forge comments ("Wow, Elon Musk liked my idea!" and there is no proof that he didn't) and claim that you wrote things that you never wrote.
- So my idea was that a comment author needs to publish a public key (somthing like /.well-known/public-keys/tim.crt), and a signed hash must be part of the permalink. So more like <feed-url>#<keyname>+<signature>. The signed hash must include all the essential parts of the comment (author name, inReplyTo, title, pubDate, body), e.g., in a JWS format. That way, an owner can legally prove that the comment they republish is legitimate. An extra field in the hash ({canBePublished: true} or {license: 'CC0'}) could also solve potential copyright issues when republishing comments.
- A key name is required because you can't expect users to manage their keys, especially if they are using multiple clients. It's much easier when a client app creates a new public/private key pair each time it is installed, and then uploads a new public key to the server.
- My unsolved problem right now is: what happens if someone just deleted their public key and claims they never owned it...? There needs to be some way to either publish the public key itself, or to have it validated...
- RSS readers should validate the signatures, at least for some comments (like checking every 100th and report the comment if invalid).
Reactions (likes...)
- I think the simplest solution for likes is to use a single-character comment. To like a post, just send a ❤️ as comment
- The CMS or RSSmention server can then count reactions.
Policies / Capabilities
- Realistically, if you use feeds not only for personal blogs, but also for forum-style discussions to replace subreddits or Facebook groups, you need to define policies/capabilities for comments that you accept.
- A feed that allows RSSmention comments must declare what's allowed in comments. Links/URLs? Images? Tables? Max length? Title allowed/required? Required license? The goal is that the RSS reader (client) only shows options to the user that are allowed in comments for that particular feed. If you don't do that, it's very frustrating for users to see when the comment they wrote is not accepted.
- A feed that allows reactions must declare which reactions (a string with all possible reactions should be sufficient, like "❤️👍👎")
- You probably need to link some document with ToS or rules for groups.
- In other words, this requires an RSS extension that links to the RSSmention URL and describes the capabilities / policies.
Watching the KDE Documentary is really fun. I worked on KDE for a few years in the early 2000s, and it brings back so many memories. I met most of the people in the documentary on the KDE IRC channels back then, and some also in real life at KDE conferences.
The craziest thing was certainly the moment Apple announced that Safari was based on KHTML. It wasn't something I had worked on, but we were on IRC, watching the Apple live stream back then, and had no idea. Then, out of nowhere, they mentioned KHTML. Things got crazy.
Sometimes, using Claude is just wild. It had to render Markdown. But I forgot to tell it which library it used. Because I didn't see any package.json change, I asked it. This was the answer:
How Markdown is rendered. There's no library. I wrote a small renderer in markdown.ts (about 400 lines, with 13 tests) because of your "vanilla, only our helpers" rule. It also turned out to be the safest option:
Security: it builds DOM nodes with newHtml/addHtml and never produces an HTML string or uses innerHTML, so a hostile about.md can't inject markup. Raw HTML in the file is dropped and its text kept. Only http(s), mailto and tel links are created, and images must be http(s). Relative URLs are resolved against the site.
Supported: headings (shifted down one level, because the page's h1 is the profile name), paragraphs and line breaks, bold, italic, strikethrough, inline code and code blocks, quotes, nested lists, horizontal rules, links (inline, reference and bare URLs), images, and footnotes.
What's even crazier: it works really well.
I'm back
I'm back from my vacation, Lisbon → Barcelona, with a few extra nights in each city. 
Besides sore feet, I also brought a loong to-do list for Downread, and a concept for truly distributed comments via RSS. More on that later.
Liking RSS Items
While RSS.chat mostly solves the issue of comments (at least read-only), it does not really solve the issue of liking in a distributed system - it depends on a central server. So either there is still a centralized system, assuming everybody would use the same likes server, or every feed has a different server and you need to authorize with them before you can like something. And even that does not do a good job preventing like-spam.
My solution for liking is different:
- every feed still needs a like-server, but in order to like, you don't need to log into them. The like-server must implement the webmention protocol.
- every user maintains a JSON feed of their likes - for all their sites. If you like something, add the like to your OWN RSS like feed, at a fixed, permanent URL, and use webmention to notify the site of your like.
- when an article is being liked, the site's like-server publishes the like in its own JSON feed which contains a list of all the likes it got with their permanent URL.
This system makes sure that every like can be validated and allows you to detect cheaters. Clients should validate at least one like before accepting the like count and showing it.
Users can only like once per hostname. By default, the like server must only accept one like per second-level domain, to avoid someone creating dynamic domain names to add an infinite number of likes. Only whitelisted domains can like with subdomains. This should limit the ability to cheat.
And if like-cheating is getting out of hand, there could be a validator service that requires additional proof from likers the first time they like something. But that would be a later step.
SocialSpec
I discovered SocialSpec today, which is pretty close to what I intended with sosocial.dev. It is currently mostly focused on user profiles, not on social-media feeds, but maybe it's something we can collaborate on.
Instagram / Tiktok / Reels / Shorts - like RSS feeds
I am working on concepts to have independent, simple web servers providing RSS/Json-based protocols to give users the same viewing experience as Facebook/TikTok/YouTube/X/Reddit/Instagram. This is where we are:
- The usual blog system is the equivalent of Facebook posts
- Video podcasts are the equivalent to YouTube
- Microblogs are the equivalent to X.
But where is the equivalent to Instagram and TikTok? Those swipable full-screen images or videos with text overlay?
I think all the data can already be in the feed today:
- The enclosure/attachment would be the main image or video. The one that's in the background on Tiktok/Shorts
- The post description would be the text on top of the video
- Instagram posts have multiple images. In RSS, the MediaRSS extension can handle several images (alternatively, multiple enclosures could be sufficient, but they don't have per-image titles). In JSON Feeds, attachments have all we need. However, I am not aware of any RSS reader supporting more than one image.
So we have all the data. The reader just needs the right hints to render it correctly. Let's call them card-based feeds.
So two things are needed.
- a flag in the feed to make the RSS reader display it as a series of card-based posts
- a backward-compatible convention that lets existing readers render additional media.
The RSS / JSON Feed extension (proposed)
Giving the RSS Readers a hint to display a post as a card-based post is relatively simple with extensions.
For XML, we can use a simple new element in our own namespace to make an item as a card:
<card xmlns=‘https://sosocial.dev/' />
(side note: XML namespaces are wonderful and pretty much the only time I prefer XML over JSON)
JSON Feeds also support extensions, albeit in a less elegant way. We need to put something like this in our feed:
"_sosocial": {
"about": "https://sosocial.dev/",
"cards": true,
}
Backward-compatibility
Backward-compatibility for existing readers is very simple as long as the feed has only a single image/video per post: just do nothing. A typical reader will display the image/video at the top, and the text underneath. Not perfect, but it will work anywhere.
Multiple-images are more difficult. I would propose to duplicate all images but the first into HTML, marked with a special class. Card-supporting readers will filter them out. Existing readers will display them.
That basically means that every item with multiple images starts their HTML with a special div:
<div class="sosocial-alt-card">
<img src="/img1"/>
<hr/>
<img src="/img2"/>
<hr/>
<img src="/img3"/>
</div>
Card-supporting RSS readers will not display 'sosocial-alt-card'. All others will show it.
P.S.: I bought the domain sosocial.dev when it was on sale for just $1. I was too lazy to check there is already a company of the same name. So I need a new domain...