Over the past few weeks, I’ve been inspired by the many developers building new social apps on top of Bluesky’s AT Protocol, and I decided to start my own project: Currents, an open and decentralized alternative to Pinterest.
I published it a few days ago, still in “alpha”, and the code is available at this link. I’d also like to use this project as an open, public laboratory where I can experiment with topics that interest me but that I don’t get to explore in my day job.
One of those areas is recommendation systems. In this article I want to describe how I built the first version of Currents’ feed, which has the distinctive feature of being more or less personalized depending on the user’s preferences.

With this slider, users can adjust a parameter — which we’ll call α — that controls the level of personalization of the feed. Here’s an overview of how the system works.

From pixels to embeddings

The first part of the system transforms every saved image into an embedding: a 768-dimensional vector that encodes the meaning of the image. Images are mapped into a shared 768-dimensional space, where vectors representing similar images are close together, and vectors corresponding to semantically distant images are far apart.

These vectors are stored in a column of a PostgreSQL database (using the pgvector extension), which, thanks to an HNSW index, allows efficient retrieval of the nearest vectors to a given input.
The model used to produce these embeddings is SigLIP 2, which has a notable property: it can project both images and text into the same vector space. This means it’s possible to do text-based image search by turning a query string into an embedding and using it to retrieve the most similar image vectors.

Personalized feed

To build a personalized feed, I drew inspiration from PinnerSage — Pinterest’s recommendation system published in 2020 — and from how Bluesky’s Discover feed is generated, with some simplifications to keep Currents as lean as possible.

Both of those approaches run a clustering algorithm on embeddings to create groups of pins or posts, from which representative items of the user’s taste are drawn. Instead of running a dedicated clustering step, I decided to use the user’s own collections as clusters. Every time a user saves a new image to a collection, the medoid of that collection’s embeddings is recalculated — that is, the item that minimizes the sum of squared distances to all other items in the collection — and used as the representative embedding for that collection. Using the medoid rather than the mean of the vectors ensures that the representative always corresponds to a real image the user chose to save.

To generate the personalized feed, the medoids of the user’s 3 most “important” collections are taken, and a similarity search is run across all embeddings in the database, retrieving the items most similar to those 3 reference points. To determine which collections are most “important”, I used the same formula as PinnerSage, which weights saves by recency:

One downside of this approach is that users don’t always organize their collections by topic — for example, someone might create a collection called “2026” containing everything they saved that year — meaning the collection medoids may not be truly representative. Using a dedicated clustering algorithm could be more effective; that’s an experiment I plan to run in the future, once Currents has enough users to measure the impact. For now, this is the simplest and most practical approach I’ve found.

Serendipity

On the opposite end of the slider from the personalized feed, there’s the label New worlds. When the slider is moved toward that end, the feed follows a concept called serendipity.

Most recommendation systems we use today optimize for accuracy: they try to show us more and more of what we already like. A well-known downside of this approach is the filter bubble problem: users end up seeing only content that fits their existing tastes, limiting exposure to anything new or different.

For a creative person, I think this problem is especially relevant. Serendipity aims to solve it by maximizing recommendations that are unexpected yet still somehow relevant.

While it’s difficult to measure serendipity objectively, I decided to build a system that follows this principle and use it as a baseline for future experimentation.

The implementation is straightforward: once a day, a clustering pass is run over the entire image space to group images by similarity. (Dimensionality is first reduced to 50 dimensions using UMAP, and then HDBSCAN is applied for clustering, mitigating the so-called curse of dimensionality.)
Feed generation then works similarly to the personalized feed, with one difference in the 3 reference embeddings: instead of using the medoids of the 3 most important collections, for each of those collections we take the medoid of the nearest cluster whose items the user has never saved.
This forces the recommendation of items from clusters the user hasn’t explored, while keeping them adjacent to their known interests.

The α parameter

The two methods described above correspond to the two extremes of the slider’s spectrum. The slider controls α, which ranges from -1 to 1 and can take any value in between. This allows blending recommendations with a global feed: for example, with α=0.4, 40% of the suggested images come from the personalized feed and 60% from the global feed; with α=-0.7, 70% come from the serendipitous feed and 30% from the global feed.
The global feed ranks images by novelty and popularity using the following formula:

Conclusions

This project will be a personal laboratory for experimenting with interesting ideas, but I also hope it becomes an app that genuinely solves problems that users of similar apps face. I’ll keep listening to make it something that truly works for them.
Thanks for reading :)
Matteo

[1] Pal, Aditya, Chantat Eksombatchai, Yitong Zhou, Bo Zhao, Charles Rosenberg, and Jure Leskovec. “PinnerSage: Multi-Modal User Embedding Framework for Recommendations at Pinterest.” Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, July 7, 2020, 2311–20. https://arxiv.org/abs/2007.03634

[2] Wesley-Smith, Ian. “Personalization at Bluesky: The past, present, and future of personalization of the Discover feed.” RecsysML + LLMs, February 23, 2026. https://recsysml.substack.com/p/personalization-at-bluesky

[3] pgvector — Open-source vector similarity search for Postgres. GitHub. https://github.com/pgvector/pgvector

[4] Hierarchical navigable small world (HNSW). Wikipedia. https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world

[5] Roy Gosthipaty, Aritra, Merve Noyan, and Pavel Iakubovskii. “SigLIP 2: A better multilingual vision language encoder.” Hugging Face Blog, February 21, 2025. https://huggingface.co/blog/siglip2

[6] McInnes, Leland, John Healy, and James Melville. “UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction.” arXiv:1802.03426, February 9, 2018. https://arxiv.org/abs/1802.03426

[7] McInnes, Leland, John Healy, and Steve Astels. “hdbscan: Hierarchical density based clustering.” Journal of Open Source Software, 2(11), 205, March 21, 2017. https://doi.org/10.21105/joss.00205

A few months have passed since I first started feeling the need for a space where I could write about what I think and what I do. Within a few days, that urge — paired with the desire to explore SvelteKit as a full-stack framework — gave shape to this blog.

I was very happy with the elegant, minimal look I had achieved after just a few iterations. The only missing piece was a comments section at the bottom of each article: the thought that what I write here could spark interesting discussions is perhaps the thing that drives me most to write on the web.

And that’s how I ended up in an endless cycle of research — the kind I dive into every time I’m faced with the burden of choosing a tool or service for some new project. This time, though, it didn’t take me long to realize the choice was almost a given: Disqus, born in 2007, spread quickly and became the most widely used service by online publications of all sizes. That’s probably why I already knew about it, and my research only served to reinforce some of the opinions I had already formed over time.

To begin with, Disqus’s main revenue source is advertising. This means that, as highlighted in this and this article (and there are countless others online), blog pages turn into full-blown ad boards over which the author has absolutely no control. On top of being aesthetically unpleasant and yet another sneaky way for tech companies to harvest data, this also takes a toll on performance: every time an article loads, a barrage of ads (with their links, images, and videos) must be downloaded by the reader’s browser, inevitably degrading the experience.

Moreover, something many people overlook is the ownership of comments, which live on Disqus’s servers. This means that neither the author nor the readers have full control over what happens to them: they could all vanish overnight for no apparent reason.

During my research I discovered several alternatives that try to address some of these issues (for example, Commento and Hyvor Talk), but it was when I stumbled upon this article by Emily Liu that a quirky idea began to take shape. Emily was, at the time, “Head of Special Projects” at Bluesky, a social network that positions itself as an alternative to Twitter (now X) with some interesting peculiarities.

As explained in her article, and in other posts on the same blog, Bluesky is a decentralized and open social network. Decentralized in the sense that user data lives across multiple servers, and users themselves can handle it as they please, moving it from one server to another with complete freedom. Open in the sense that all of Bluesky’s source code is open source, and its APIs are free and available to everyone.

These are perfect conditions for using Bluesky posts as comments. All you have to do is publish a post on Bluesky mentioning that you’ve written a new article on your blog and then, with a simple call to the Bluesky API from the article’s page, you can display all replies to that post on the same page, as if they were comments on the article itself. Other people (see this and this article) had started adopting the same approach on their blogs, so, intrigued, I decided to try integrating it into my embryonic blog — and I immediately noticed at least two limitations. The process of adding a new article became cumbersome: first I publish the article, then I publish the post linking to the article, and then I use the post’s identifier to republish the article with the correct Bluesky API call. A real hassle. On top of that, readers couldn’t authenticate directly in the comments section to interact (leave a like, repost, or reply with a comment) — they had to open the post on Bluesky to do so. Too much friction for a reader who simply wants to join the conversation.

So I figured I could solve these problems and, after a few months of tinkering, today I published Juttu, an open source software that follows the same logic but addresses the issues I just mentioned. You can install it by copying these three lines of HTML, using your own DID and giving the article an ID of your choice (for example, “my-first-article”).

<!-- in <head> -->
<link rel="site.standard.document" href="at://YOUR_DID/site.standard.document/YOUR_ARTICLE_SLUG" />
<script defer src="https://cdn.jsdelivr.net/npm/juttu@latest/juttu-embed.js"></script>

<!-- in <body> -->
<div id="juttu-comments"></div>

The result is visible in the comments section below, while the code — which you can find in this GitHub repo — can be browsed, forked, modified, and self-hosted freely by anyone. The documentation is available at this link.

While creating Juttu I got to know the community called “ATmosphere,” the community of applications built on AT Protocol — the open protocol created by Bluesky to allow building applications with “social” features that share the characteristics mentioned earlier (open and decentralized), and more. Inspired by what the members of this community are building, I’d also love to try my hand at creating a social network based on AT Protocol, but that’s material for another article.

What’s certain is that I’ll commit to refining and improving Juttu to make it a solid alternative to Disqus. The first topic I’ll tackle is comment moderation: on this front, Bluesky and AT Protocol provide dedicated tools that I’ll need to figure out how to integrate. Let me know if you try installing Juttu on your blog — any feedback is more than welcome at this early stage.

Thanks for reading :)

Matteo

[1] Rosanna. “Watch Out for Ads! Disqus Comments Have Gone ‘Premium’.” By Rosanna, April 16, 2018. https://www.byrosanna.co.uk/blog/watch-out-for-ads-disqus-comments-have-gone-premium

[2] Southgate, Ryan. “Goodbye Disqus — Your Injected Ads Are Horrible.” ryansouthgate.com, September 30, 2025. https://ryansouthgate.com/goodbye-disqus/

[3] Commento — Add Comments to Your Website. Commento.io. https://commento.io

[4] Hyvor Talk — Privacy-First Commenting Platform. Hyvor. https://talk.hyvor.com/

[5] Liu, Emily. “Using Bluesky Posts as Blog Comments.” emilyliu.me, November 24, 2024. https://emilyliu.me/blog/comments

[6] Liu, Emily. “How Your Newsroom Can Use Bluesky This Election Season.” emilyliu.me, January 24, 2024. https://emilyliu.me/blog/bluesky-for-elections

[7] Liu, Emily. “Benefits of an Open Network.” emilyliu.me, November 24, 2024. https://emilyliu.me/blog/open-network

[8] Zue, Cory. “Adding Bluesky-Powered Comments to Any Website in Five Minutes.” coryzue.com, November 25, 2024. https://www.coryzue.com/writing/bluesky-comments/

[9] Moallem, Jonathan. “The Absolute Simplest Way to Use Your Bluesky Posts as a Blog Comment Backend.” Caps Collective, November 26, 2024. https://capscollective.com/blog/bluesky-blog-comments/