You don’t really need to understand the details, just know that it helps filter out spam. If you’re still seeing spam, you can raise the threshold a bit.
Good suggestion 👍
Yeah, I’ve been debating whether it makes sense to split it into multiple, separate filters.
Everyone starts with the same score. The system then recalculates reputations iteratively, and after enough rounds the scores converge and stabilize.
It’s a good idea, but it wouldn’t help with the initial reputation issue. A new user would still need the inviter to follow them in order to gain any reputation.
How does an account get reputation? I like the approach but it typically leads to cold start problem
Exactly. If a newcomer starts completely disconnected from everyone in the network, it’s indeed hard to enter the trust graph. But if they come to Nostr through someone they know, they can gain some initial reputation from that recommender, enough to help them stand out from the spam accounts.
A new user only needs to be followed by a regular account to boost their reputation into the top 60%, since spam accounts rarely get any followers, following them would expose the spam account owner.
I’ll take a look at those NIPs 👍
It’s basically a simple combination of the PageRank and TrustRank algorithms, both of which have plenty of resources online.
In short, if you’re followed by high-reputation users, your reputation goes up too. The more trusted users vouch for you, the more trustworthy you become.
You don’t need to do any configuration. You might want to double-check that your code is up to date, and try refreshing the page a few times since it could be cached.
Fill the form to get the invites to the call: https://formstr.app/i/wotathonsignup
We usually meet every Thursday but this week is on Friday, the 2nd.
I would love to get you presenting a bit of this approach, focusing on what you need as a client and probably how simple solutions can work. The group is mostly service providers that have a hard time figuring out what clients need (especially which formats are better/easier)
I’m not really into meetings, mostly because my English isn’t great haha. But if your protocol is out on GitHub or somewhere, I’d be happy to check it out and throw in a few suggestions.
Sounds great! What do you need me to do?
I initially thought about the new user issue as well. But I realized that new users are usually brought in by an existing user, once that user follows them, their reputation is higher than that of spam accounts.
It doesn’t seem that important, but yes, most of the code was generated by AI. I just handled the review, fixed AI’s mistakes, and made some small optimizations.
This is bound to be a long-term battle.
The main purpose of this filter is to weed out spam accounts. Since there are a lot of spam users on the Nostr network, normal users usually end up in the top 10%. But this isn’t fixed, so the choice is left to the user. To avoid filtering out too many legitimate users, I’ve set the default threshold at 40%.
The scores are currently based on the network of relationships, your reputation increases when followed by high-reputation users. Since there are a lot of spam accounts in our network, most normal users end up in the top 10%.
I think this is quite different from a social credit system.
Sounds like an interesting idea
The last feature of https://jumble.social/ in 2025:
A reputation filter that hides notes from the bottom X% of users by reputation.
It works across feeds, notifications, and replies, and is especially effective at reducing spam when browsing large public relays. #devstr

Fixed! Thanks for your feedback 💜

Why is he replying to a kind:6 event? 😂
Jumble indeed doesn’t handle this case, I didn’t expect this to happen at all. Now I’m really curious which client he’s using.
https://git.mleku.dev/mleku/smesh/src/branch/master/DDD_ANALYSIS.md
nostr:npub1syjmjy0dp62dhccq3g97fr87tngvpvzey08llyt6ul58m2zqpzps9wf6wl i am forking jumble because i have lots of time at the moment and first thing i wanted to do before changing anything, was get a domain driven design analysis done. i will leave this in the repo where you see it now, you might be interested to read it or at least skim it.
nostr:npub1m4ny6hjqzepn4rxknuq94c2gpqzr29ufkkw7ttcxyak7v43n6vvsajc2jl also, i know you know some stuff about various dev/design/architecture modalities, this is how things are done with DDD
just from first few screenfuls i can see a lot of things that i've noticed with other front end projects, especially the anemic domain model. in my own code i have for quite some years tended towards making a mess at first, and then after i find myself with several 400+ line functions, i go hard on refactoring, moving types that seem to live together into their own packages, and so on, and for which reason you can see here:
https://git.mleku.dev/mleku/next.orly.dev/src/branch/main/DDD_ANALYSIS.md
which was the state of orly until a few days ago (shortly after that was committed) that it evaluated my work pretty good, first it was 7, then after cleaning up the complexity of the 600+ line event handling code, i got upgraded to 7.5, still lots more to do.
i also applied it to the plebian-signer (forked from nostr:npub1qdjn8j4gwgmkj3k5un775nq6q3q7mguv5tvajstmkdsqdja2havq03fqm7 's gooti - i think he wrote that?) and here is the analysis of the codebase, after i added a ton of features, i wanted to get it cleaned up:
https://git.mleku.dev/mleku/plebeian-signer/src/branch/main/DDD_ANALYSIS.md
the signer, in particular, became noticably more performant after applying all of the recommendations in that document, and when i fully complete orly, i think it will also improve, though i have also added a new skill to https://next.orly.dev which is about go memory management and scheduling (just look in the .claude/skills directory). for go, there is some specific architecture to memory management, and what types go on the stack, what goes on the heap, and how to reduce allocations on the heap, and move stuff, especially stuff that the DDD analysis should be immutable, onto the stack, where it is very cheap pass by value (ie, copy) and thus enforce effective mutability with minimal cost.
Sure, I’ll find some time to go through it properly.
Fixed
Been hacking on top of some apps made by nostr:nprofile1qyxhwumn8ghj7mn0wvhxcmmvqy8hwumn8ghj7mn0wd68ytnddaksqgqmcu9qzj9n7vtd5vl78jyly037wxkyl7vcqflvwy4eqhxjfa4yzyr2p7gd (x21) and nostr:nprofile1qythwumn8ghj7ct5d3shxtnwdaehgu3wd3skuep0qyt8wumn8ghj7etyv4hzumn0wd68ytnvv9hxgtcqyphydppzm7m554ecwq4gsgaek2qk32atse2l4t9ks57dpms4mmhfx5ltf6v (ants) to integrate a native wallet to the Jumble experience and find ways for AI to improve the nostr experience (no API keys required)
Looking for more ideas #asknostr
https://blossom.primal.net/77685c761afc033f2067e3aa3e76a7687880f8905d67e1755ece8b42fd73c7b7.mp4
Very inspiring. Lots of great ideas.
No, you’re totally right, it was a bug and it’s fixed now 🫡

Because there’s a space in the emoji shortcode, Jumble didn’t recognize it as an emoji.
Appreciate it, but save the big zap for someone who needs it more than me
I’m using bitcoin-connect, how should I add the metadata?
Yes, but it’s already the blossom server that Jumble recommends. I’d like to add another one to the list.
That's exactly what I've been focusing on for the past half year. That’s also why I’ve been putting off some new features.
We can know whether an event was delivered, but doing so would make the publishing process feel very slow.
I don’t think it’s worth sacrificing the experience for these rare cases. In most cases, sending succeeds, and if it fails, retrying will likely fail too—it could be a network issue or the relay simply refusing your event.
It’s all in `/src/services/client.service.ts`, but it’s a bit messy.
Usually a reply gets sent to around ten or more relays. To achieve what you’re imagining, you’d have to wait for all of them to respond or time out, which would make the user experience really poor.
That said, it’s true that Jumble marking a post as successful after just one relay accepts it isn’t ideal. I’ll adjust it so it only shows success once maybe a third or half of the relays have confirmed.
Maybe it’s just that the other person set unsuitable relays, or maybe only one or two relays failed — should the user really have to see error messages all the time for that? In most cases, a few relay failures aren’t a big deal. If you need absolute reliability, that’s what centralized platforms are for.
I get your point, but the solution isn’t to fork Jumble. What we really need is a better nostr development kit.
A lot of clients are built on top of NDK, but the problem is that NDK itself has issues and isn’t very actively maintained. That’s actually why I decided not to use NDK in the first place.
It’s hard to track reliably, and in some cases certain relays are simply unreachable.

