Matrix 2.0: How we’re making Matrix go voom
fosdem.org
fosdem.org
It works wonderfully, it became a really nice hub of communication, information sharing with dedicated rooms for different stuff (CI/CD, link sharing, planing, etc.) and the service has no downtime I can remember in the past year.
Highly recommended and this funds indirectly the development of Matrix.
So I don't know where you got "there's nowhere for you to go" from.
Element has open source apps and that's great. It just seems to not have a very strong culture of people self-hosting it. Though one comment did provide me a place to look and I found this and am now more comfortable with it. https://schildi.chat/ Still it would be great to see it have some big instances like GitLab does with Debian, Freedesktop, and others. Then I wouldn't feel I was going it alone if I self-hosted it.
Element: landing page https://element.io/solutions/self-hosted-or-cloud-collaborat...
GitLab: all the things https://about.gitlab.com/install/ at the bottom is the Debian package, but if you go to the Docker Page and click the username you can see gitlab-ce there as well.
You probably want to read the open-source software's installation instructions at: https://github.com/vector-im/element-web
TLDR, check out the project, run `yarn install`, then edit the config file, then `yarn build`.
And, yes, that is all there is to it. It's significantly simpler to deploy than GitLab.
Finally, you keep mentioning self-hosting; you _can_ just use a non-self hosted application like the downloadable version of Element, SchildiChat, Fluffychat, or any other client.
No reason to bring hosting into the mix for the client, if that's causing concern.
To me it looks like they come with proprietary stuff: https://element.io/pricing
Especially Group Sync seems like something to drive you into their paid offerings, I assume by keeping the code close to the vest.
> The Dockerfile used for building public images is in Omnibus Repository
You can host bridges yourself too
You yourself say in a different comment that you are currently assessing Element: https://news.ycombinator.com/item?id=34779070. Either you have a formed opinion Matrix, or you don't. Which one is it?
You keep saying Element instead of Matrix, and obviating the whole Matrix ecosystem. Matrix protocol has several server implementations, and many more things around: https://matrix.org/docs/projects/try-matrix-now
T
- Matrix is the protocol, Element is confusingly both the hosting service and the mobile app, and Synapse is the server -- just to get terminology right
- Matrix actually does the "multiple clients" thing really right [0]
- I think a lot of people self-host; I did and there are a few others in this thread. It's easy if you've any experience hosting web API servers. A core Matrix goal is to be decentralized, so self-hosting is thus also a core goal. You can see docs here [1], or docs for Docker here [2] if that's your thing.
[0]: https://matrix.org/clients/
[1]: https://matrix-org.github.io/synapse/latest/
[2]: https://github.com/matrix-org/synapse/tree/master/docker
Also, Element is just some JavaScript in your browser or electron shell, there's no need to self-host it really, although you can (just put some HTML+CSS+JS up on a webserver) — you want to self-host Synapse, and that's trivial to do (there's a Debian package, a Docker image and so on).
I'm comparing Element.
> and so isn't Element
It sure seems to be. Look at the red X's and green checkmarks in the comparison: https://element.io/pricing There are different opinions on what Open Core means though.
This is in fact a bit of a problem wrt. funding: https://matrix.org/blog/2022/12/01/funding-matrix-via-the-ma...
[1] https://github.com/vector-im/element-meta/issues/260
[2] https://github.com/turt2live/matrix-dimension/blob/master/do...
It's been working flawlessly since I deployed it (about 2 years ago now).
Amusingly, two of my co-workers from a previous job also run their own homeservers, one a smaller private instance similar to mine and the other a single-user node that bridges many different chat systems together for personal use. The two of them also interact with the users on my homeserver on a regular basis in various public and private channels.
I should note that only one of the active users in the channels on my server is from matrix.org - everyone else is from the same server or federated instances run by other people. Matrix.org could go down tomorrow and things for us would mostly keep running just fine.
I do wish Synapse had a proper account invite system for private servers, and not the "spin up a matrix.org account and chuck the hapless fool in the hopefully-federated room" method that was there the last time I tried.
I was in the same position, wanted to set one up - decided it was too much work.
https://github.com/spantaleev/matrix-docker-ansible-deploy/
Been hosting it alongside some bridges(like irc) for a while now.
Shameless plug - for people who'd rather not maintain their own server manually with Ansible, a few others and I are running https://etke.cc - a completely FOSS service service built on top of the Ansible playbook. Hopefully, this provides the best of both worlds - ease of getting started (on your own or on a rented server), everything built on top of FOSS, no vendor-lock-in (you can migrate to using the playbook yourself at any time, etc.).
But you want sysadmin pain points, here are some random pointers in no particular order:
- Familiarity with reverse proxies helps a lot. I recommend terminating both client (443) and federation (8448) traffic through nginx or similar.
- The Synapse Github (https://github.com/matrix-org/synapse/issues) is one of the first places I start trawling if something gets weird.
- Federation is the second-hardest part, and if something goes wrong and you're not watching the Synapse logs it can fail silently - here it helps to have friends on other instances there to check connectivity (and blame you when THEIR instance breaks federation, that's fun). https://federationtester.matrix.org and similar help a lot too, and it's good to at least have a couple of bots from matrix.org to poke at if you suspect something's amiss.
- Fuck everything about troubleshooting STUN/TURN. Newer playbooks may make coturn deployment easier.
- It's easy to test migrations/deployments with an update to your hosts file - you can verify that your clients connect to the new server and that data has been restored without doing anything to the original server.
EDIT - Keep in mind that a lot of the above went on from 2018-2019 (except the server migration, but that was easy) and the documentation/automation has improved quite a lot since then.
I'm hosting a small set of services (Nextcloud in particular) for a group of friends, and the same thing is happening here. At some point, I added an email reset to my LDAP system so that people can reset their passwords themselves. I don't know how "normal" people live like that. I can't remember the last time I used a password reset other than for technical reasons.
Dendrite, conduit and synapse - matrix homeserver software (you have to use one of them) have thousands of stars.
I'm pretty sure atleast 10k+ matrix homeserver deployments exist - maybe someone from matrix.org can give a better number because each homeserver is probably federating with theirs.
And thats to say nothing of unfederated servers i.e. orgs hosting matrix for internal use.
Edit: looks like there's a 50 user minimum for business plans?
https://github.com/spantaleev/matrix-docker-ansible-deploy/b...
In my experience Element for Android starts off pretty fast, but as the weeks progress it gets slower and slower to load chats. Element on Linux does not have that problem, and neither does Schildichat for Android. It is my client of choice, anyone frustrated by a slow client should try that one on for size.
That said I'm excited for the new version. I used this Ansible/Docker setup, easy as pie:
Hopefully that improves your situation
"No video with supported format and MIME type found."
Not a great UX, but certainly not worth anyone getting upset about, given FOSDEM is seemingly volunteer driven.
May I say, I am SHOCKED at how much they have been able to accomplish. Incredible. I'm sure it's not all rainbows but the demos were amazing.
Matrix.org has also been breached in the past [2].
That's ignoring the fact their project was born out of a company that operates front offices for one of the world's most aggressive spy agencies...
[1] https://medium.com/@fs0c131y/tchap-the-super-not-secure-app-...
[2] https://matrix.org/blog/2019/04/11/we-have-discovered-and-ad...
AMDOCS has been accused multiple times of being an extension of Mossad, including in the US where the investigations got quietly ended. Leaked cables from 2009 showed they were also on the radar of South Africa's intelligence agency [1].
[1] https://www.news24.com/news24/spy-cables-were-israeli-spies-...
shady because of accusations?
2. Yup, unfortunately matrix.org got pwned 4 years ago. (Thankfully E2EE means that encrypted conversations weren't compromised). This was a (bad) sysadmin fail; again, nothing to do with Matrix, the protocol, or the implementations (and the rest of the network was of course unaffected).
3. I've never seen any evidence of Amdocs being involved in spying, and many of the accusations there seem to be rooted in antisemitism. They acquired the two companies (one UK, one French) which turned into Matrix in 2010; we span out and set up Element in 2017.
Then we can finally try and bring in everybody who's currently trapped in proprietary IM.
Both the servers and the clients will have to be updated to leverage them.
The features already exist serverside; we're just working on getting them out of beta.
I am hopeful it also improves resource usage, bringing it closer to hydrogen.
Is this also for the desktop/browser version?
Unfortunately making it a "real" macOS app is much harder, as the UI is currently uses UIKit in a bunch of places to make up for feature and performance limitations in SwiftUI. These would have to be ported over to AppKit to run on macOS. I had a go at it over the holidays, but it's not trivial - perhaps someone with more AppKit skills than I could make it work (or maintain a fork) though.
To give an idea of the amount of UIKit that would need to be swapped out:
matthew@shadowfax ElementX % find . -name \*.swift | xargs perl -ne 'while (/[^a-zA-Z](UI[A-Z].*?)[^a-zA-Z]/g) { print "$1\n" }' | grep -v UITest | sort | uniq -c | sort -rn
52 UIKit
31 UIImage
20 UIApplication
13 UIScrollView
12 UITextView
11 UIDevice
11 UIConstants
10 UIColor
5 UIViewController
5 UIRectCorner
5 UIKitBackgroundTask
5 UIKeyCommand
4 UIView
4 UIPasteboard
4 UIBackgroundTaskIdentifier
3 UIViewControllerRepresentable
3 UITableView
3 UIScreen
3 UINavigationController
3 UIKitBackgroundTaskService
3 UIFont
3 UIActivityViewControllerWrapper
3 UIActivityViewController
2 UIViewRepresentableContext
2 UIViewControllerRepresentableContext
2 UITextViewWrapper
2 UITableViewDelegate
2 UIResponder
2 UIHostingController
2 UICollectionView
1 UIViewType
1 UIViewRepresentable
1 UITraitCollection
1 UITextViewDelegate
1 UITableViewDiffableDataSource
1 UITableViewController
1 UITableViewCell
1 UIScrollViewDelegate
1 UIKitAttributes
1 UIHostingConfiguration
1 UIContentSizeCategory
1 UIBezierPath
1 UIApplicationDelegateAdaptor
1 UIApplicationDelegate
1 UIActivityI've got a lot of experience with AppKit and may be down to look at doing that fork once the churn on Element X is lower...
That'd make hydrogen minimally usable. Currently, all the other clients that are logged in constantly nag about an unverified and unverify-able hydrogen session existing!
Hydrogen works on older / weaker computers, where element is unusable.
e.g. share a link to a GitHub repo or a photo and be able to quickly say something in the same sheet without having to switch to the app and say the thing and the back to my browser
edit: had to use YouTube in the end: https://www.youtube.com/watch?v=eUPJ9zFV5IE
I'd say that this will remove my last hesitation I've had in recommending Matrix to people.
What Matrix 2.0 fixes were true pain points which didn't keep me from using Matrix with my closest friends, but kept me from pushing Matrix to most people.
For a complete example, not that long ago (couple months), I had to wait over 10 minutes to send a message to somebody on Element on Android (on the street, trying to meet with them), because I turned connectivity on at that moment for the first time that day, and syncing took that long.
Now, this is instant, so is joining new rooms; This meets most people's expectation.
Having native videoconference is also very welcome, but the old hack was not a deal-breaker.
So you had to sync all of the messages on the server first before sending a message?
Sync still takes a second in large rooms, but you no longer need to download a thousand messages just to see the three latest ones.
Maybe before 2020?
And that's not even getting into the computational and network problems moving and saving all that state causes as addressed in this very update about how they're trying to mitigate the architectural problems I just mentioned. But they'll only be mitigations. And the legal/social problems will still exist and since everyone (ie, 99%) of people use the Riot.im/Element.io matrix.org homeserver that means social/legal pressures can be easily applied.
I like Matrix. I even use it for video chat because of the sars-cov-2 pandemic. But it is no hope for freedom.
And I say that as a regular on multiple IRC networks, some through Matrix bridge.
Notably missing is voice chat. I use the Mumble client [5] with the Murmur or uMurmur [6] server which is light-weight enough to run on ones home router. I use it on Alpine Linux, works great. It's not a shiny and attention grabbing as Discord but probably fine for everyone else. For people to create their own voice channels would require the full-blown Murmur server.
[1] - https://github.com/thelounge
[2] - https://thelounge.chat/
[3] - https://github.com/convos-chat/convos/
[4] - https://convos.chat/
[5] - https://www.mumble.info/
But this doesn't change the fact that irc is obscure minority now, no matter how many shiny web interfaces we put on top of it, so embracing the actually open platform that has a chance of gaining any traction is a no-brainer.
Agreed. I still use it when I need a quick way to chat. That and Devzat SSH chat. I can fire up NGIrcd in about 3 minutes and most of that time is dealing with LetsEncrypt. UnrealIRCD is my preferred IRCD but the configuration is more involved so I don't bother since most people moved to Discord.
Out of curiosity since I have never used Matrix, how many clients can one node/server simultaneously support approximately?
Sorry, I don't know if I'm being honest :) The one I run is used by just few people. Matrix isn't so "internal community" focused like Mastodon in its federation.
At that point you've just reimplemented a less-standard version of matrix with extra steps though. Your protocol has become heavyweight and non-standard (you could argue it degrades gracefully to IRC, but in practice using your enhanced server from an unenhanced client will always be painful), you're holding state on the server in the same way you were worried about (and without the mitigation of E2EE)...
There are IRCv3 specifications that allow this richer experience, and they are at least as standard as Matrix. Check out https://ergo.chat/ with modern clients like https://sr.ht/~emersion/goguma/ (Android), https://git.sr.ht/~emersion/gamja/ https://kiwiirc.com/ (web), or https://git.sr.ht/~taiite/senpai (TUI)
> but in practice using your enhanced server from an unenhanced client will always be painful
IRCv3 normally makes sure new specs don't make it worse for older clients. Could you give me some examples to see if we can fix that?
"At least as standard" how? A substantial portion of the IRC comunity is actively hostile to the IRCv3 extensions, and in some cases prefer incompatible implementations of the same functionality; Matrix has nothing like that going on. And there seem to be more visibly independent implementations of Matrix than IRCv3.
> IRCv3 normally makes sure new specs don't make it worse for older clients. Could you give me some examples to see if we can fix that?
Speaking generically rather than IRCv3-specific, things like: server-side history extensions tended to mess up my client's history implementation (I'd end up with multiple copies of the same messages in my local logs, often with the wrong timestamps). And if you're in a conversation where people are using embedded gifs, then fundamentally you'll always be a second-class citizen if you're trying to participate in that with a client that can't display embedded gifs. (Or for a more serious example, SSO access control; you just can't do that in a nice way if the client doesn't support it). This kind of thing is what killed the Slack IRC gateway, and it comes back to the first point, because it's ultimately more of a social issue than a technical one: a substantial portion of the IRC community uses clients that don't support these things not because they can't but because they're hostile to the very idea of having embedded gifs or SSO in IRC.
There are 8 people who vote on changes to the Matrix spec (the Spec Core Team), 7 of which are Element employees (including Matthew, Element's CEO). Element also controls the development of clients and servers used by the large majority of users in the public federation.
The IRCv3 working group is made of plenty of organizations (non-exhaustive lists at https://ircv3.net/participation / https://ircv3.net/charter) with at most two "representatives" each.
> A substantial portion of the IRC comunity is actively hostile to the IRCv3 extensions, and in some cases prefer incompatible implementations of the same functionality; Matrix has nothing like that going on.
But any IRC client will work fine on any IRC server, and they can simultaneously connect to various servers which support variants of the protocol (eg. through capability negotiation). Also note that 75% of servers support IRCv3 capability negotiation: https://www.ircstats.org/server-features/cap (and the others are often at all not developed anymore)
On Matrix, clients (generally) can only connect to one homeserver at a time; which forces them to converge on following the same spec. And if your server differs ever so slightly from the other ones in how it implements some parts of the spec (room consensus), then it can be split-brained from the rest of the federation. Instead, changes to the room consensus are done by pushing new room versions, and each server implementation needs to explicitly support it or they can't join it. This means Synapse devs (which are a majority of Element employees) get to decide what room versions can get traction.
It is not uncommon for people in the Matrix community to complain about this and Element keeping specs in limbo, and PRs to the flagship clients being stuck in "design review tar".
> And there seem to be more visibly independent implementations of Matrix than IRCv3.
Clients, maybe, at least in the number of implementation. It's hard to find stats of this, but I feel that >95% of people in the public federation use Element even in tech-y rooms; IRC has a healthier mix of major clients (weechat, irssi, IRCCloud, Hexchat, KiwiIRC, The Lounge each have >5% of desktop/web users). But I admit that's just my very subjective point of view.
In terms of servers, Matrix has three open source ones as far as I know: Synapse (controlled by Element), Dendrite (controlled by Element, and almost on par with Synapse according to https://arewep2pyet.com/ ), and Conduit. Based on https://gitlab.com/famedly/conduit/-/milestones/3 , Conduit seems to be far from implementing the spec yet (eg. it doesn't seem to support leaving rooms or respecting history visibility). And I can't think of any non-Synapse server, besides Matrix devs self-hosting.
Meanwhile, IRC servers: https://www.ircstats.org/servers (note: this counts servers and not networks or users)
> things like: server-side history extensions tended to mess up my client's history implementation (I'd end up with multiple copies of the same messages in my local logs, often with the wrong timestamps)
You can use https://ircv3.net/specs/extensions/message-ids to deduplicate them.
> And if you're in a conversation where people are using embedded gifs, then fundamentally you'll always be a second-class citizen if you're trying to participate in that with a client that can't display embedded gifs.
A conversation where people are using embedded gifs will exclude me regardless of client, because they are too distracting. At least on IRC I can expect people not to do it too much, and use words or emojis instead of reaction gifs.
Speaking of which, Matrix does not provide a way to provide alt-text to images and videos, which ends up excluding plenty of people as well. (To be specific, the spec technically does provide a way, but clients use it for filenames instead: https://github.com/vector-im/element-web/issues/22100#issuec... )
> SSO access control; you just can't do that in a nice way if the client doesn't support it
That's a fair point; IRC is made by hobbyists more than companies, so that's not surprising. There is some discussion around it though: https://github.com/ircv3/ircv3-ideas/issues/74 and Sourcehut is sponsoring design and implementations (https://emersion.fr/blog/2022/irc-and-oauth2/).
There is a bunch of missing context here. Firstly, Matrix predates Element. When the team who created Matrix set up the Spec Core Team, we deliberately went for a 4:5 mix of folks from the founding project team mixed with folks from the community. Specifically: me (Matthew), Dave, Erik and Rich from the original team, and Hubert, Travis, Andrew, Alexey and mujx from the wider Matrix community. At around the same time, the original Matrix team set up Element as a way to try to fund us to work on Matrix as our dayjobs.
The catch however is that Hubert/Travis/Andrew got so enthusiastic about Matrix that they wanted to do it as their day job - and at the time, Element was the only place you could do that, and so they applied to work at Element. We reasoned that the best outcome for Matrix would be if they were able to work on Matrix fulltime, and so prioritised that over the heterogeneity of the Spect Core Team. They were explicitly asked to participate in the SCT discussions with their community rather than Element-employee hats on, though, and they continue to do so.
Finally, the actual Guardians (Directors of the Matrix Foundation) who ensure that the project remains neutral are 3:2 mix of independent v. Matrix founders. So if anyone thinks that the SCT is deviating from its neutrality, they can and should appeal to the Guardians, who then have the ability to shake up the SCT as needed.
So yes, this is more complicated than a simple 'design by committee' approach, but I'd argue that it gives the ability for the protocol to evolve more rapidly and with less bikeshedding - and meanwhile we have the checks & balances to keep things on track.
> This means Synapse devs (which are a majority of Element employees) get to decide what room versions can get traction.
The official room versions are defined by the SCT; nothing to do with synapse devs. It's the SCT which prevents fragmentation. Synapse and other homeservers can (and do) go wild experimenting with different room versions.
> It is not uncommon for people in the Matrix community to complain about this and Element keeping specs in limbo, and PRs to the flagship clients being stuck in "design review tar".
Yes, it's very common for people to complain that their favourite feature hasn't been added to the spec yet, or that their unsolicited PR to Element got wedged because the Element team is trying to build a focused coherent app rather than a kitchen sink.
On spec stuff, the solution is to implement the feature anyway on a prefix, demonstrate its usefulness, and then the MSC is easy to unblock. On unsolicited PRs to Element, the solution is to demonstrate it on a branch, or fork, or implement it on a different client. Again, features which have been proven to work well in the wild are easy to incorporate into the official spec.
But you have to admit, irc is a tiny tiny part of IM usage popularity wise, and it's not for no reason.
Curating and sharing links is the same as hosting. And I’m quite happy to be on a platform which doesn’t share or host this content.
> At our request, the EMS-hosted Libera.Chat bridge regularly prunes idle connections to minimize disruptions to IRC channels during bridge restarts.
(Also, only about 35% of users we're aware of are on the matrix.org server, not 99%...)
Most of what you complain about societal pressures either apply to IRC (access to specific servers) or outright fail IRC by default by not providing the feature (state).
To be honest this is probably reason #1 why people stopped using IRC. We want to see the messages that were sent while we weren't here. Yes I know what a bouncer is, no this is not a good solution.
IRC as a protocol is simple and elegant but as a product it doesn't meet today's users expectations at all. And you can't just say users expectations are wrong and they should just align with what IRC provides, it doesn't work like that.
I've been slowly getting wow'ed by the current developments in Nostr, which could be a great, new open protocol for social media. The native implementation of lightning network payments, and the ability to follow paid relays without needing to be bound to them is pretty cool.
Will it be easier than before?
(I've written several IRC clients, and a simple one could be done in an afternoon with only a sockets/TLS library. But when I looked at Matrix briefly, implementation seemed very big-moat. And now it's a rapidly moving target.)
Servers are definitely harder - it's probably similar complexity to writing a git implementation (given it's basically doing the same operation: synchronising DAGs of commits between replicas of a chat room).
In terms of it being a rapidly moving target: from memory we've never broken backwards compatibility on Matrix since day 1 back in 2014. "Matrix 2.0" is not a breaking change; it's just adding some new APIs to change performance to be O(1) rather than O(N) (and switching to OIDC for auth and native VoIP for multiparty).
So, overall, I'd say it makes things easier: both Matrix client & server authors will no longer have to mess around implementing custom auth (which was a huge burden to get right), but be able to use existing mature OIDC implementations. Meanwhile, the new sync API should be as easy as the old one (although we haven't really done a like for like comparison yet, given we've been obsessing about driving the new sync API as efficiently as possible)
Not sure which "any of the other tablestakes features" you have in mind... obviously if you want loads of features, then you're going to have to write a whole bunch of code to implement them in your client, or build on an existing SDK like matrix-bot-sdk, matrix-rust-sdk, matrix-js-sdk etc. Not sure that's a disadvantage of Matrix though(!)
The conventional IETF-ish Internet ideal of open standards is to have a specification that is implementable.
When the selling point is security, insecure implementations don't help us.
Suggesting an off-the-shelf proxy kludge doesn't clearly answer how implementable it is.
Sounds like you're saying that the protocol (with necessary security) is hard to implement. Do the new changes affect that one way or the other?
Of course "Arathorn" would say it's easy to implement a client for the protocol he controls unilaterally, it's in his interest to get you locked in!
There is one cross platform client for matrix and it drives the features: element
I say this from a place of current experience, as I run a server and use element and fluffy chat, each of which has its own issues. If it's so easy, where are the others? Why is there only one third party home server available that is only partially implemented? XMPP offers at least three to choose from. Now /that/ is a real protocol
There is zero benefit for choosing matrix over XMPP
I'm not sure using a proxy is my preferred solution either, but if you're worried about insecure implementations doesn't it make a ton of sense to separate the E2EE implementation from the rest of the client implementation?
My ideal when using an experimental Matrix client if I don't know the developers involved would be for their experimental code to be quarantined away from the encryption code. That way I don't have to worry so much about whether their implementation is insecure, I know they're just using something off-the-shelf.
Whether the proxy in specific is the best way to do that, :shrug:, but my instinct is that pushing messages through some kind of separate encryption/decryption handler that can be verified on its own and reused by multiple clients isn't a bad idea. That approach seems like good security practice to me. Am I missing something?
The script in your follow-up github link is still missing escapes of tokens and room id (which can both be arbitrary strings according to the specs) btw. And you should add 500/502/503 error handling, these happen fairly often on non-tiny accounts in my experience, even outside matrix.org
> from memory we've never broken backwards compatibility on Matrix
* https://spec.matrix.org/v1.5/changelog/ has a handful of "Breaking changes" sections since 2021
* https://matrix.org/docs/spec/client_server/r0.6.0.html#chang... , https://matrix.org/docs/spec/client_server/r0.5.0.html#chang... , etc. have a few more before 2021
* Removing reply fallbacks (recommended by MSC3676 and already implemented by at least some clients) causes other clients to miss notifications
On Telegram it works fine for me.
It saves you the trouble of opening two apps. Nothing more.
We should have telegram style bridge that let's you talk to WhatsApp accounts without having an account in WhatsApp.
Maybe EU DMA will do it? I don't know
That seems like a strange statement to preface with "IMO".
I use the Element One subscription, with bridges to Signal and WhatsApp.
It enables a bit more than "not having to open two apps" (although that in itself is nice). It means that I have one, good, client on any platform I want and it has all the messaging. I don't have to double up the client on every platform I want to read/write messages on.
Plus, I get a proper backup of all my messages without having to worry about how that happens on WhatsApp and Signal (the Signal situation is a bit complicated here).
We're running an ancient build. Is your Synapse installation walk-through [1] still the latest/greatest guidance in getting started, for those looking to refresh their environment?
Also, https://thirdroom.io/ is very interesting!
Even now, after nearly 12 months the reference client manages to lock android up (multiple devices, 11-13) to the point where every other app hangs and the only fix is a reboot.
There are ecosystem failings too but none of those are as bad as having exactly 0 usable clients on a platform that has such a huge market share.
I want to know if you intend to fix it or just ignore it? (For Aaron)
Also as a bonus answer, how 45 million ends up with nothing to show for it.
We would like GitHub integration, strong spam/moderation features, and avoid the hassle of self-hosting. gitter.im used to provide those, but they were lost in the Matrix switch.
I set up Maubot for GitHub integration: https://github.com/maubot/github. There are moderation features, but we haven't had to use them.
Some example Matrix communities which seem to work well include Mozilla (chat.mozilla.org), GNOME (https://matrix.to/#/#community:gnome.org) and KDE (https://webchat.kde.org/). Smaller ones include folks like Helix editor: https://matrix.to/#/#helix-community:matrix.org. I don't think anyone's written a guide for getting up and running though, which in retrospect is a crying shame; we'll get it on the todo list.
(p.s. thanks for Hex Fiend! :D)
Well, yes and no. The moderation features might be the same, but:
1. It's a lot easier to make matrix accounts, especially if you run your own server.
2. The user interface for blocking an entire server is basically missing? The only thing I can find has you run a bot to do it?
So if someone with their own homeserver wants to troll you, you end up playing wack-a-mole unless you self-host a bot. At least that's the best I can find so far.
I don't know how well the public Github bots will work for your use case. The moderation tools are also relatively crude in my experience; at the protocol level reports/ACLs/reporting is quite easy to use, but there's no easy Matrix moderator frontend that I know of. There's a bot (mjolnir) but not a separate UI.
You can pay people to host your Matrix server or you can use the public home servers to set up your community/spaces. Self hosting usually isn't necessary.
Is there some github repo or some other place where orgs are discussing this?
Superficially, Matrix looks a bit like SIP: for 1:1 calls, you send an m.call.invite (like a SIP INVITE) to someone; they answer with an m.call.answer (like a SIP 200 OK); eventually someone hangs up with an m.call.hangup (like a SIP BYE). However, the differences are:
* As a transport, everything goes over normal Matrix signalling (by default HTTPS+JSON) rather than SIP's mix of UDP and TLS sockets. As a result, no need for SIP's three-way handshakes inherited from its UDP transport
* As a result, you inherit Matrix's end-to-end-encryption and decentralisation for free (so no special Routes, Vias, Record-Routes, branch parameters etc from SIP - it uses the Matrix client-server and server-server APIs over HTTPS instead)
* Everything is trickle ICE by default for rapid call setup, no need to wait until you have all the ICE candidates to proceed with the call
* No offerful/offerless invites: everything is offerful.
* Matrix piggybacks on WebRTC for its media protocol, so you don't have the fragmentation of different media transports that SIP has inherited
* Matrix (as of https://github.com/matrix-org/matrix-spec-proposals/blob/mat...) now supports multiparty native VoIP calls in the same conversation: effectively letting you signal full-mesh, SFU and MCU style multiway video/voip using the same mechanism as you'd use for a 1:1 call. This is probably the biggest difference in the end: with Matrix's VoIP you can jump straight in and have interoperable Zoom/Teams/Jitsi style conferences (as shown in the OP at https://youtu.be/eUPJ9zFV5IE?t=1513) - Matrix isn't just for boring old PSTN/PBX-style 1:1 calls, but for the conferences folks actually expect to use today.
You can play with it at https://call.element.io, and if you really want to compare with SIP, go to the developer tools in options and turn on callflow mode, which will draw little mermaid sequence diagrams of the call signalling for the calls, so you can see precisely what's going on :)
Some thought that by introducing a new protocol they could generate better business/profit. I see no other advantage in Matrix.
There's nothing important in Matrix that can't be done in SIP, and there's nothing in Matrix that's much more deserving of a new protocol. There are many standard extensions for SIP, and if you're still missing something, it's easy to add.
Disclaimer: I am a SIP fan and I hate reinwenting the wheel
Zulip is the actual game changer in innovation of the conversation flow and makes the team actually more productive. Topic focused conversation flow make things actually productive and it made us a lot more productive.
And Zulip now supports public mode , look at official rust community and zulip's chat.zulip.org . It drives collaboration.
What have I missed? Could you share a review or something that goes into the difference?
- Topic can be organized easily and smart
- Full markdown + Topic + Back referencing topics so you can use it creatively , a a chatroom + knowledgeable system.
- Well architect , well documented , all architecture decisions are documented , code is very readable and modifiable (i modified it to make it work like a realtime project management system and we ditched odoo , jira ) .
Here is what zulip with topics look like :
Here is how we modified and patched it to become a realtime project management system.
I actually think that interface would be contrary to my use case which is a chat system for mostly non-technical staff. The closer to what they're already familiar with the better and Rocketchat works great for that. I think Zulip would be confusing.
I'll file Zulip away in case I'm doing a more tech focused project in future.
I wanted then to use it to run my own for romance chat purposes, why reinvent the wheel. Well there's the official python server and the Go version isn't feature complete.
All I got out of the element client were a few nude pics and message streams that were completely uninteresting. Also there were so many pedophiles on there that I refused to be associated with them and deleted everything. I reported and blocked so many but it's no use.
No matrix for me.