It seems that you're currently allowed to attempt to create spaces containing uppercase characters.

When the space is created, you're redirected to a url to that space containing the uppercase characters, and you get a 404.

This one is inspired from reddit; Upvotes/Downvotes and "Karma".

On matrix, this is hard, because you need to have each event be associated to their corresponding user and server, and so any "vote" (be it an upvote or a downvote) is associated with a user.

However, when you have anonymity coupled with the voting, something strange can happen where an "invisible hivemind", who does not wish to be exposed to harassment or be identified, can vote on a certain article/comment, and (to some degree) exert a "wisdom of the crowd" onto a certain subject or opinion.

However, this anonymity and universal access comes with one problem; spam, and/or "botting" the vote, to influence the upvote/downvote ratio with a horde of automated requests.

Reddit handles this by centralising access to the upvote/downvote mechanism, and anonymising the public aggregate to number and ratio. It applies some clever algorithm behind the scenes to detect popularity, and fixes a position on the "front page" with that "velocity".

The problems with HummingBard, then, are the following;

1. How can you anonymize voters?
2. How can you allow voters to retract or alter their vote after casting it?
3. How can you aggregate this in an efficient manner, while keeping anonymity?
4. How can you be spam-resistant in this system? (resistant, not invincible, as i think this will become a tradeoff and a compromise)
5. Is it possible to make easy calculations for how popular or how "active" a post is, in this manner?

(Note: not "repost", "reposting" is the act of taking a post and copying it wholesale into a new one, basically plagiarising the original post if it is original content such as Art or Literature)

One thing that turned out to be a Hard Problem across HummingBard is the notion of "reblogging"/"retweeting"/"boosting", or here, called "repeating" (like a classic telecommunications Repeater).

The specific part where this becomes a hard problem to solve is when events need to be referenced outside of their respective rooms, somehow.

Lets say that feed X creates post Alpha (A), this post is liked and replied to in its own manner, now lets say that feed Y, possibly over federation, wants to "repeat" post Alpha. This "repeated" post will be referenced with A'.

How would this be accomplished in a manner that allows the other feed to view post A''s edits, comments, reactions, and other things, while also allowing tumblr-style "chaining" (or quoting, from the twitter world) of these posts?

Lets say a "chained" post is called post Beta, B, this post has an internal reference to Alpha, so it is B{A'} (if i can continue to use this pseudo-algebra for a second).

In twitter semantics, quote-tweets, this is just a "soft link", with the original post being able to be deleted, and the "quote" showing that the original tweet was deleted.

In tumblr semantics, reblogs, this is a "hard link", with the original post being able to be deleted, but it's contents "carrying on" with each subsequent reblog. (this also had some internal security issues, where the contents of this reblogged post could be edited by clients before sending to the server)

So there are three questions;

1. What kind of linking would we want for HB? I mean the difference between such "hard linking" and "soft linking". (I'm personally leaning towards hard linking, because that allows some social dynamics that tumblr was able to capture very well.) Maybe we could have the user be able to choose this for themselves? "Sub-post" vs "quote".
2. How can we make this efficient? If you have a hard-linked (or even soft-linked with transient visibility of each sub-linked post) post with many edits, reactions, or other "relations" to each individual post in the "chain", how to you efficiently fetch and/or store this?
3. How can this be resilient? Matrix rooms are self-contained, if any server fails, that means that as long as you have your local copy of it, and have a local user in the room, you can have legitimate access to that post. This is not the case when event references cross rooms, because the dynamics of which server is joined in that room, or which server even has the event, changes with this. Then, how can you design a system that is able to preserve links between posts in a true manner, in a way that could update the reactions, comments, and other relations when able, and store efficiently and reliably when any one server, user, or post in that chain (when it's hard-linked) is deleted or not accessible anymore? (Think also about room upgrades, where an event is only accessible in a room with a previous version, and when every user moves on from that, it is hard to find, or even possibly insecure to access, or - when room versioning has gone this far - it is incompatible with the software of the current homeserver)

The 'Join @space' button joins a room (returns right json), refreshes the page, but it seems like the session doesn't update. Clicking join again seems to update the session.

Probably not part of any near-term plans, but might make for a good help-wanted task?

Most obvious pick for early tests is probably https://github.com/nodegui/svelte-nodegui

Later on Tauri might present an even better alternative, but it’s still a bit early: https://github.com/tauri-apps/tauri