element-x-ios VS hydrogen-web

Matrix is a protocol, not an app, and it's still evolving rapidly.

Meanwhile, Element as an app is also evolving rapidly too. Totally agreed that the onboarding has been awful in the past, but we're plugging away improving it and trying to make it more glossy and less neckbeardy, as per https://element.io/labs/element-x etc.

The fact is that Discord has raised $1B+ to run a centralised unencrypted comms platform; meanwhile Element is doing something ~10x harder (decentralised & E2EE) with a tiny fraction of the $. It takes longer, but the difference is that Matrix should last indefinitely, whereas Discord will get Eloned sooner or later.

I wouldn't say we've lost yet, but ymmv. I do wish we'd progressed faster though.

Element X is not finished or intended for average users yet, as https://element.io/labs/element-x makes clear. It’s a preview of the future of Element.

Matrix itself is a big messy thing, much like the Web - this is both its power and a potential weakness.

Element X is indeed a fancy new client - but it hasn't hit a 1.0 yet. Think of it a lot like Firefox was pre-1.0; it's unrecognisably faster and better than the previous generation... but not all features are there yet. Meanwhile, there are loads of entirely unrelated independent excellent clients out there too; it's not just about Element v Element X.

> But I wasn't able to set up the encryption with my recovery key, there was only the online validation which I couldn't use because I was on the go and didn't have access to my desktop.

This bug is an accidental thinko however: it's placeholder UI which is about to be replaced by implementing login-via-scanning-QR-code (which is almost there), but obviously that also needs the ability to enter recovery keys too. Eitherway, it's being fixed: https://github.com/element-hq/element-x-ios/issues/2424

> also seems to still lack TOFU for my private server

Yup, sorry, TOFU for TLS isn't implemented yet in EX.

> The same with the homeservers, there's synapse and dendrite is supposed to take over at some point but that point is forever far in the future. And then there's conduit, so which one is it?

Synapse is a stable server where the core team is putting its effort currently. Dendrite is a 2nd gen server from the core team, but is beta and a) ended up being focused on P2P and embedded homeservers and experimental MSCs, b) is starved of resource atm due to funding pressure (c.f. https://www.youtube.com/watch?v=s5BrVVf0B1I&t=316s). Conduit is an independent server implementation in Rust, which is promising but beta.

It's like asking whether you should use Apache httpd or beta versions of nginx or lighttpd in the early days of the Web.

> The strategy doesn't really feel well thought out in that sense.

The strategy at Element (which employs most of the Matrix core team) is pretty clear right now:

1. Improve Synapse as the most mature and stable server implementation (and package it in Element Server Suite for those needing an enterprise Matrix distro: https://element.io/server-suite)

2. Finish implementing sufficient features in Element X that it can replace the old classic Element mobile apps asap - converging on a single Rust codebase, so that bugs & audits & new features can all land in one place.

3. Keep building Element Web/Desktop and Element Call.

...and that's it.

If it seems confusing, that's either because we're in the middle of the Element -> Element X shuffle... or because the nature of Matrix is that there's loads of other independent implementations running around too. But that's what makes it fun, too :)

i’d have been in danger of agreeing a year ago, but thankfully we proved otherwise with Element X: https://element.io/labs/element-x. Bit embarassing that we didn’t get there sooner, but human fallibility and all that.

Yep, a good example is the element X rewrite

They use Jetpack on Android

https://github.com/vector-im/element-x-android

And SwiftUI on iOS

https://github.com/vector-im/element-x-ios

But both use the same underlying Matrix Rust SDK

https://github.com/matrix-org/matrix-rust-sdk

So they share the core part of the app between platforms, but everything user facing is native

And the cake under the cherry is… Element X is open-source[1][2]!

I really can't wait for Beeper[3] to rebuild their fork on top of Element X (it's currently based on Element, formerly called Riot). If this happens this will be an absolute game-changer in the messaging ecosystem.

[1] https://github.com/vector-im/element-x-ios

[2] https://github.com/vector-im/element-x-android

[3] https://www.beeper.com/

Yes, eventually. Right now the sliding sync MSC is still in flux (e.g. we just realised today that it's missing an explicit flag to notify once the client has caught up with the server, rather than guessing via heuristics: https://github.com/vector-im/element-x-ios/issues/1269#issue...). As a result, the implementation (which is in golang) is being kept separate from Synapse for now while we iterate on it; plus it's a separate set of folks working on it. This also means that SS can be used with any existing server (dendrite, conduit etc) as needed.

It'll get added natively to Synapse eventually, but it'll likely be quite a way off.

Element X is an entirely new client written in Rust + Swift UI/Jetpack Compose (https://github.com/vector-im/element-x-ios and https://github.com/vector-im/element-x-android) which will eventually replace the legacy Element apps (https://github.com/vector-im/element-ios and https://github.com/vector-im/element-android).

The features already exist serverside; we're just working on getting them out of beta.

Yep, it's definitely been frustrating in the past. The number of iOS Element bugs was overwhelming at times too. It's a lot more stable now, but the bubble layout still isn't the default - I think that's what most people expect from a personal messenger. I'm looking forward to seeing what the Rust rewrite [1] brings for performance/stability.

FluffyChat also has quite nice UX and a bubble layout by default, but threads are still a while off [2]. On iOS it worked flawlessly through the iOS 16 betas while Element had some show stopping bugs, a couple of my friends moved over if they were on the beta.

I haven't had any friends ask me about the verify session buttons. I don't see any prompts on latest iOS Element but it's still too prominent on Element desktop for my liking.

SchildiChat [3] is my daily driver and feels more friendly than Element on desktop (unified DMs & group chats, no verify UX, chat bubbles), but it doesn't have any update mechanism built in, so I'm wary to recommend it to non-technical friends. It was also my goto recommendation on Android before the Element redesign.

I'm confident the ecosystem is moving in the right direction though, and so thankful for the amount of choice.

[1]: https://github.com/vector-im/element-x-ios

iOS is still not great, but they are making a new one.

Yes! See https://github.com/vector-im/hydrogen-web/releases/tag/v0.3....

I think you're right, the experience of element on Android isn't great, I use mostly the web app that seems to get more attention and doesn't feel as sluggish. But to bring some hope, I think this will change soon-ish. The Matrix ecosystem has been in kind of a MVP state for several years, the focus was more on the protocol/APIs and not so much on the performance that translates in user experience. But efforts are on the way to improve all of this, on the client side there are several projects working on other clients that might be more performant, including the company behind Element, they have a work-in-progress lightweight client https://github.com/vector-im/hydrogen-web On the server side most servers run Synapse which is written in Python without much though for performance or scalability but there are faster/lighter alternatives on the way like Dendrite or Conduit. It also doesn't help that most accounts are in the same overcrowded Synapse server(matrix.org), overtime it should become more common to have more alternatives and people even running their home server embedded in their device.

It’s using normal Matrix olm/megolm double ratchet encryption.

To track the identity of who you’re talking to we can do TOFU and/or normal out of band Matrix verification as per https://github.com/vector-im/hydrogen-web/issues/518 - but this isn’t yet exposed in Chatterbox. We’ll get it added, as without verification you obviously can’t spot a MITM.

You can use this web app to access the chat. Join the #general channel. https://github.com/vector-im/hydrogen-web

Hydrogen's installation process was pretty much exactly the same as Element, the github README was just a lot less specific and there is no config file so you have to edit the HTML directly to get it to point to your site instead of matrix.org by default.

> I'm rather convinced at this point that all of these people chanting "Can we just go back to traditional approaches!" have never built a web app of reasonable complexity, never used something like React, or have some sort of combination of FOMO and/or comfort in their long-held approach.

I've got plenty of React & front-end experience and vastly prefer a thin library on top of the DOM than something like React, also for large applications. React is ok if all goes well, but when you have to debug or profile something, all the complexity behind the scenes occludes what you are looking for. Most of the time, people want JSX so you need a transpiler. Also keeping up with changes in new React releases seems like a lot of lost time.

I've been building [1] without a transpiler and just a 600 lines template library (see [2]), and it has been such a breath of fresh air. The fact that there is so little code between you and the browser makes it very easy to see what is going on. Call stacks of max around 15 frames.

It sounds like you are comparing React to jquery code without components, and I justed wanted to highlight that DOM APIs have evolved since those days, and that you don't need a library like React to structure your code.

React has popularized good ideas in front-end development, like components, but I think the complexity cost of a virtual DOM is often underestimated.

1: https://github.com/vector-im/hydrogen-web/

Matrix's resource utilisation is improving very rapidly at the moment.

Dendrite is still in beta, and hasn't been tuned that much yet, but every release has had a substantial improvement. In other words, if you're not using today's release (0.3.5) you're on stale data. For context, dendrite.matrix.org (running 0.3.5) has ~5K users on it, and is in ~3K rooms spanning 162K users... and its RAM usage is stable at 488MB (occasionally spiking to 2GB during traffic spikes). This doesn't seem unreasonable at all for a chat server of that size. Meanwhile, Synapse has been steadily improving too.

On the client side, Hydrogen (https://hydrogen.element.io, https://github.com/vector-im/hydrogen-web) is our next-gen client implementation, which gives you full E2EE, complete with backup (I have no idea what Durov is banging on about in the OP) - and uses 14MB of RAM for an account in 3,000 rooms spanning 350K users (i.e. my personal one). This is an 100x improvement on Element Web which uses 1.4GB for the same account, although there's also a lot of optimisation that can be done there too.

If I was going to criticise Matrix, I'd focus more on the fact that there are still a lot of papercuts on Element's UX which are holding us back. We're painfully aware of this though and are trying to fix as rapidly as we can.

it’s a entirely new codebase; probably best way to visualise progress is to look at the contributor graphs at https://github.com/vector-im/hydrogen-web