It's been over a week since our next-generation homeserver Dendrite entered
beta, and it's
been a wild rollercoaster ride as the team has been frantically zapping all
the initial teething issues that came up - mostly around room federation
getting 'stuck' due to needing to fix bugs in how room state is managed. Huge
huge thanks to everyone who has spun up a Dendrite to experiment and report
bugs!
We're now in an impressively better place, and it's feeling way more stable now
(but please don't trust it with your data yet). So we've skipped 0.1.x and jumped
straight to 0.2.0.
Now would be a great time for more intrepid explorers to try spinning up a
server from https://github.com/matrix-org/dendrite and see how it feels - the
more feedback the better. And if you got scared off by weird bugs in 0.1.0,
now's the right time to try it again!
Full changelog follows:
Dendrite 0.2.0 (2020-10-20)
Important
This release makes breaking changes for polylith deployments, since they now use the multi-personality binary rather than separate binary files
Users of polylith deployments should revise their setups to use the new binary - see the Features section below
This release also makes breaking changes for Docker deployments, as are now publishing images to Docker Hub in separate repositories for monolith and polylith
The new latest tag will be updated with the latest release, and new versioned tags, e.g. v0.2.0, will preserve specific release versions
Sample Compose configs have been updated - if you are running a Docker deployment, please review the changes
Images for the client API proxy and federation API proxy are no longer provided as they are unsupported - please use nginx (or another reverse proxy) instead
Features
Dendrite polylith deployments now use a special multi-personality binary, rather than separate binaries
This is cleaner, builds faster and simplifies deployment
The first command line argument states the component to run, e.g. ./dendrite-polylith-multi roomserver
Database migrations are now run at startup
Invalid UTF-8 in requests is now rejected (contributed by Pestdoktor)
Fully read markers are now implemented in the client API (contributed by Lesterpig)
Missing auth events are now retrieved from other servers in the room, rather than just the event origin
m.room.create events are now validated properly when processing a /send_join response
The roomserver now implements KindOld for handling historic events without them becoming forward extremity candidates, i.e. for backfilled or missing events
Fixes
State resolution v2 performance has been improved dramatically when dealing with large state sets
The roomserver no longer processes outlier events if they are already known
A SQLite locking issue in the previous events updater has been fixed
The client API /state endpoint now correctly returns state after the leave event, if the user has left the room
The client API /createRoom endpoint now sends cumulative state to the roomserver for the initial room events
The federation API /send endpoint now correctly requests the entire room state from the roomserver when needed
Some internal HTTP API paths have been fixed in the user API (contributed by S7evinK)
A race condition in the rate limiting code resulting in concurrent map writes has been fixed
Each component now correctly starts a consumer/producer connection in monolith mode (when using Kafka)
State resolution is no longer run for single trusted state snapshots that have been verified before
A crash when rolling back the transaction in the latest events updater has been fixed
Typing events are now ignored when the sender domain does not match the origin server
Duplicate redaction entries no longer result in database errors
Recursion has been removed from the code path for retrieving missing events
QueryMissingAuthPrevEvents now returns events that have no associated state as if they are missing
Signing key fetchers no longer ignore keys for the local domain, if retrieving a key that is not known in the local config
Federation timeouts have been adjusted so we don't give up on remote requests so quickly
create-account no longer relies on the device database (contributed by ThatNerdyPikachu)
Known issues
Old events can incorrectly appear in /sync as if they are new when retrieving missing events from federated servers, causing them to appear at the bottom of the timeline in clients
Memory can explode when catching up after a federation outage.
Not only are UK/US/AU/NZ/CA/IN/JP considering mandating
backdoors, but it turns out that the Council of the European Union is working on it too, having created an advanced
Draft Council Resolution on Encryption
as of Nov 6th, which could be approved by the Council as early as Nov 25th if it passes approval. This doesn't directly
translate into EU legislation, but would set the direction for subsequent EU policy.
Even though the Draft Council Resolution does not explicitly call for backdoors, the language used...
Competent authorities must be able to access data in a lawful and targeted manner
...makes it quite clear that they are seeking the ability to break encryption on demand: i.e. a backdoor.
Please help us spread the word that backdoors are fundamentally flawed - read on for the rationale, and an alternative
approach to combatting online abuse.
Hi all,
Last Sunday (Oct 11th 2020), the UK Government published an international statement on end-to-end encryption and public safety, co-signed by representatives from the US, Australia, New Zealand, Canada, India and Japan. The statement is well written and well worth a read in full, but the central point is this:
We call on technology companies to [...] enable law enforcement access to content in a readable and usable format where an authorisation is lawfully issued, is necessary and proportionate, and is subject to strong safeguards and oversight.
In other words, this is an explicit request from seven of the biggest governments in the world to mandate a backdoor in end-to-end encrypted (E2EE) communication services: a backdoor to which the authorities have a secret key, letting them view communication on demand. This is big news, and is of direct relevance to Matrix as an end-to-end encrypted communication protocol whose core team is currently centred in the UK.
Now, we sympathise with the authorities’ predicament here: we utterly abhor child abuse, terrorism, fascism and similar - and we did not build Matrix to enable it. However, trying to mitigate abuse with backdoors is, unfortunately, fundamentally flawed.
Backdoors necessarily introduce a fatal weak point into encryption for everyone, which then becomes the ultimate high value target for attackers. Anyone who can determine the secret needed to break the encryption will gain full access, and you can be absolutely sure the backdoor key will leak - whether that’s via intrusion, social engineering, brute-force attacks, or accident. And even if you unilaterally trust your current government to be responsible with the keys to the backdoor, is it wise to unilaterally trust their successors? Computer security is only ever a matter of degree, and the only safe way to keep a secret like this safe is for it not to exist in the first place.
End-to-end encryption is nowadays a completely ubiquitous technology; an attempt to legislate against it is like trying to turn back the tide or declare a branch of mathematics illegal. Even if Matrix did compromise its encryption, users could easily use any number of other approaches to additionally secure their conversations - from PGP, to OTR, to using one-time pads, to sharing content in password-protected ZIP files. Or they could just switch to a E2EE chat system operating from a jurisdiction without backdoors.
Governments protect their own data using end-to-end encryption, precisely because they do not want other governments being able to snoop on them. So not only is it hypocritical for governments to argue for backdoors,** it immediately puts their own governmental data at risk of being compromised**. Moreover, creating infrastructure for backdoors sets an incredibly bad precedent to the rest of the world - where less salubrious governments will inevitably use the same technology to the massive detriment of their citizens’ human rights.
Finally, in Matrix’s specific case: Matrix is an encrypted decentralised open network powered by open source software, where anyone can run a server. Even if the Matrix core team were obligated to add a backdoor, this would be visible to the wider world - and there would be no way to make the wider network adopt it. It would just damage the credibility of the core team, push encryption development to other countries, and the wider network would move on irrespectively.
In short, we need to keep E2EE as it is so that it benefits the 99.9% of people who are good actors. If we enforce backdoors and undermine it, then the bad 0.1% percent simply will switch to non-backdoored systems while the 99.9% are left vulnerable.
We’re not alone in thinking this either: the GDPR (the world-leading regulation towards data protection and privacy) explicitly calls out robust encryption as a necessary information security measure. In fact, the risk of US governmental backdoors explicitly caused the European Court of Justice to invalidate the Privacy Shield for EU->US data. The position of the seven governments here (alongside recent communications by the EU commissioner on the ‘problem’ of encryption) is a significant step back on the protection of the fundamental right of privacy.
So, how do we solve this predicament for Matrix?
Thankfully: there is another way.
This statement from the seven governments aims to protect the general public from bad actors, but it clearly undermines the good ones. What we really need is something that empowers users and administrators to identify and protect themselves from bad actors, without undermining privacy.
What if we had a standard way to let users themselves build up and share their own views of whether other users, messages, rooms, servers etc. are obnoxious or not? What if you could visualise and choose which filters to apply to your view of Matrix?
Just like the Web, Email or the Internet as a whole, there is literally no way to unilaterally censor or block content in Matrix. But what we can do is provide first-class infrastructure to let users (and room/community moderators and server admins) make up their own mind about who to trust, and what content to allow. This would also provide a means for authorities to publish reputation data about illegal content, providing a privacy-respecting mechanism that admins/mods/users can use to keep illegal content away from their servers/clients.
The model we currently have in mind is:
Anyone can gather reputation data about Matrix rooms / users / servers / communities / content, and publish it to as wide or narrow an audience as they like - providing their subjective score on whether something in Matrix is positive or negative in a given context.
This reputation data is published in a privacy preserving fashion - i.e. you can look up reputation data if you know the ID being queried, but the data is stored pseudonymised (e.g. indexed by a hashed ID).
Anyone can subscribe to reputation feeds and blend them together in order to inform how they filter their content. The feeds might be their own data, or from their friends, or from trusted sources (e.g. a fact-checking company). Their blended feed can be republished as their own.
To prevent users getting trapped in a factional filter bubble of their own devising, we’ll provide UI to visualise and warn about the extent of their filtering - and make it easy and fun to shift their viewpoint as needed.
Admins running servers in particular jurisdictions then have the option to enforce whatever rules they need on their servers (e.g. they might want to subscribe to reputation feeds from a trusted source such as the IWF, identifying child sexual abuse content, and use it to block it from their server).
This isn’t just about combating abuse - but the same system can also be used to empower users to filter out spam, propaganda, unwanted NSFW content, etc on their own terms.
This forms a relative reputation system. As uncomfortable as it may be, one man’s terrorist is another man’s freedom fighter, and different jurisdictions have different laws - and it’s not up to the Matrix.org Foundation to play God and adjudicate. Each user/moderator/admin should be free to make up their own mind and decide which reputation feeds to align themselves with. That is not to say that this system would help users locate extreme content - the privacy-preserving nature of the reputation data means that it’s only useful to filter out material which would otherwise already be visible to you - not to locate new content.
In terms of how this interacts with end-to-end-encryption and mitigating abuse: the reality is that the vast majority of abuse in public networks like Matrix, the Web or Email is visible from the public unencrypted domain. Abusive communities generally want to attract/recruit/groom users - and that means providing a public front door, which would be flagged by a reputation system such as the one proposed above. Meanwhile, communities which are entirely private and entirely encrypted typically still have touch-points with the rest of the world - and even then, the chances are extremely high that they will avoid any hypothetical backdoored servers. In short, investigating such communities requires traditional infiltration and surveillance by the authorities rather than an ineffective backdoor.
Now, this approach may sound completely sci-fi and implausibly overambitious (our speciality!) - but we’ve actually started successfully building this already, having been refining the idea over the last few years. MSC2313 is a first cut at the idea of publishing and subscribing to reputation data - starting off with simple binary ban rules. It’s been implemented and in production for over a year now, and is used to maintain shared banlists used by both matrix.org and mozilla.org communities. The next step is to expand this to support a blendable continuum of reputation data (rather than just binary banlists), make it privacy preserving, and get working on the client UX for configuring and visualising them.
Finally: we are continuing to hire a dedicated Reputation Team to work full time on building this (kindly funded by Element). This is a major investment in the future of Matrix, and frankly is spending money that we don’t really have - but it’s critical to the long-term success of the project, and perhaps the health of the Internet as a whole. There’s nothing about a good relative reputation system which is particularly specific to Matrix, after all, and many other folks (decentralised and otherwise) are clearly in desperate need of one too. We are actively looking for funding to support this work, so if you’re feeling rich and philanthropic (or a government wanting to support a more enlightened approach) we would love to hear from you at [email protected]!
Here’s to a world where users have excellent tools to protect themselves online - and a world where their safety is not compromised by encryption backdoors.
In recent weeks the XR Finland community has been moving over from Wire to our own Matrix homeserver for encrypted secure chat. This was something that had been planned for a while but kicked off in recent weeks due to Wire suffering from serious encryption key delivery issues, causing messages for many to be unreadable in large groups. Currently we've migrated almost 300 rebels with more to come. Feedback has mostly been very positive, people generally like the Element clients 🤩 One of the interesting changes has been a huge uptick in the amount of discussion, which can be taken as a good sign. The plan is to next start bridging to some of the international XR chapters, for example those on Mattermost, Telegram and Slack. And maybe get them over to Matrix too eventually ;)
To aid in community management, we've started creating a bot called Bubo. Right now it mostly helps with maintaining rooms and allowing mass invites, but more features to help the community cooperate are coming. We were planning to utilize (actual) communities so it has some functionality for those, but decided then to wait for the communities rewrite. It doesn't yet have any releases, will update in coming weeks as features are added and releases made.
wants to clarify that XR is a decentralized movement and this does not mean other chapters will adapt Matrix - but we can hope and for sure here in Finland we'll be spreading the good experiences to other chapters ;)
Here's your weekly spec update! The heart of Matrix is the specification - and this is modified by Matrix Spec Change (MSC) proposals. Learn more about how the process works at https://matrix.org/docs/spec/proposals.
In terms of Spec Core Team MSC focus for this week, widgets are still the main focus: MSC2774 (widget URL template param), MSC2765 (widget avatars), and MSC2790 (modal widgets).
Dept of Servers 🏢
Dendrite / gomatrixserverlib
Dendrite is a next-generation homeserver written in Go
We released our first beta last week and we've been busy taking feedback from the community and fixing problems as they have been reported to us. We will be cutting a v0.2.0 release candidate later today, which contains a significant number of important fixes and performance improvements.
We didn't publish a full changelog last week due to the beta announcement, therefore the following list includes changes from the last two weeks:
Database migrations are now ran automatically at startup
State resolution v2 performance has been improved dramatically on large state sets, seen to be running up to 20x faster in some rooms
Dendrite no longer runs state resolution over single trusted state snapshots
Monolith deployments with Kafka now work again (each component sets up connections independently to avoid duplicate consumers)
Dendrite now correctly rejects invalid UTF-8 - thanks to Lesterpig
Fully read markers are now handled - thanks to Lesterpig
The completed field is now returned properly for user-interactive auth - thanks to Lesterpig
The devices table now tracks last seen timestamps, IPs and user agents - thanks to S7evinK
A bug has been fixed in the reverse topological ordering algorithm which resulted in us giving up on inbound references after the first prev/auth event
A bug with concurrent map writes in the rate limiting in the client API has been fixed
Forward extremities and their previous events are now checked fully against the database
Typing events are now ignored if the sender domain doesn't match the origin
Duplicate redaction entries no longer result in database errors
Some bugs in /send have been fixed where the full room state wasn't requested properly before sending a new snapshot to the roomserver
The membership updaters now use database writers properly, which fixes some SQLite locking issues
The sync API no longer burns CPU processing unnecessary device key change notifications
QueryStateAfterEvents now resolves state from multiple snapshots properly
Cumulative room state is now sent to the roomserver when creating rooms locally
Missing auth events will now be retrieved from multiple servers in the room if necessary
Federation requests now have variable timeouts, allowing us to wait much longer for a remote server to process certain tasks
The /send endpoint now returns 500 errors far less often, reducing the frequency that other servers back off from sending to Dendrite
Backfill no longer uses the request context for persisting events, which was resulting in us failing to store those events sometimes
Invite stripped state from the sync API now includes the stripped invite itself, so that Element Web can display who sent the invite properly
The signing key fetch mechanism no longer gives up if it is unable to fetch specific keys
Handling of invalid display name or avatar URLs in membership events has been improved
my personal dendrite is now in roughly the same set of rooms as my personal synapse. Dendrite is idling at 180MB of RAM, Synapse is idling at 1.8GB of RAM :)
Hello everyone, this week we merged the federation branch into master. It's not ready to be used properly yet, but we're merging it as it seems stable enough for now. We also improved performance of the federation branch a lot by turning off debug logs.
Other news:
I opened two issues on element-ios which currently break register and login support on Conduit, making it completely unusable. Hopefully they can be resolved soon (https://github.com/vector-im/element-ios/issues/3736, https://github.com/vector-im/element-ios/issues/3737)
I'm working on an MSC for threading. It's still WIP, but you can take a look here: https://demo.codimd.org/s/SykbuAUwP
Thanks to everyone who supports me on Liberapay or Bitcoin!
Stonking week for Synapse as we landed sharded event persisters and deployed to matrix.org. This is the last significant component other than the main process to go through the sharding process and a major hurdle in horizontal scalability of Synapse.
Initial results look good with event persistence apdex improving, however we think there are still some significant performance improvements available through configuration and will continue to experiment.
We also moved off background processes from the main process. This is significant because it means that while the main process is not shardable it really doesn’t do anything anymore other than orchestration.
Again the initial impact looks very promising and we will continue to tune. Having moved the background processes away it also makes profiling the main process that much easier.
Aside from all of that we continue to progress room knocking put out a 1.21.2 - a bug fix release though please please ensure you are running at least Synapse >= 1.21.0 since 1.21.0 contains a XSS security fix.
Next week we will carrying on tuning matrix.org and start to look at improving state resolution performance.
Small bit of news I wanted to talk about from Bridge Island. My implementation for MSC2409 has been merged which means appservices / bridges can now listen in for incoming presence, typing and read receipt events! This means that the Slack bridge can now reliably send your typing status to Slack, and Bifrost can reliably bridge your everything to XMPP. The MSC is still in flux and could change, but for now this could really improve the native feeling of bridges :)
(Oh and I should mention anyone using matrix-appservice-bridge v2.2.0+ can use this behaviour for free)
mautrix-python implements Half-Shot's new features
I've been adding support for the MSCs Half-Shot implemented in Synapse to my bridges:
Enabling end-to-bridge encryption now uses appservice login (MSC2778), which means setting up the shared secret login module is no longer required for e2be.
mautrix-python has support for receiving ephemeral events via MSC2409 in a branch, which will be merged once Synapse v1.22 is released. After it's merged, /syncing with double puppets will no longer be necessary to bridge ephemeral events.
Both of these will also be implemented in mautrix-go/whatsapp soon.
Now I just need Half-Shot to make synapse send to-device events to appservices, after which bridges won't need any hacky /syncing at all.
Several releases this week (0.1.11 to 0.1.15) with lots of changes:
url-based navigation has landed! All navigation in the app is now done through urls, meaning you can also bookmark any UI state (e.g. grid configurations).
fixed 2 memory leaks (exposed now because you can unload your session without refreshing the page)
fixed an issue with libolm running out of memory if you send a message to more than 44 devices (see issue #150).
some logical additions now we have url navigation: restoring the last url when opening the app with the default route, and a button to close your session and go back to the picker.
the app now blocks concurrent access to the same session from different tabs (it just closes the session in the non-active tab). This will prevent multiple syncs tripping over each other writing to indexeddb (e.g. ConstraintErrors and friends).
updates are announced in the app (for now through a confirm dialog, but will use an in app notification once we have it)
fixes updates not installing on iOS, by having an update prompt. To get this update on iOS though, you'll need to unpin the app, and pinning it again. You'll need to login again after this. All future updates should be installable through the update prompt once you have 0.1.15 though, you won't have to do this again normally.
We are currently preparing the release of the version 1.0.9 of Element Android, which contain searching messages in clear rooms and a lots of other improvements and new features.
The SDK 1.0.9 will also be released, with an updated readme, and a brand new sample app, written by Ganfra. It will help developers to start using the new SDK and can be found here: https://github.com/matrix-org/matrix-android-sdk2-sample. This sample app is able to let the user connects to an existing account on any homeserver with password login, display the room list, display a room timeline and send message to a room.
a brand new sample app
I published the first preview of my Sailfish client called Konheko. While you can run Android applications on Sailfish, they usually are a subpar experience, since they really don't fit the platforms design and style and also usually don't properly send notifications.
So about a year ago I started working on a Matrix client for SailfishOS, but I never really made much progress. Well, last weekend I did, and so it can now send plain text messages as well as various forms of media messages, I made a basic application icon and I've been using it this week already (for unencrypted rooms).
It is still missing a lot of features, but if you want you can install it from OpenRepos. Sources are available here. Just be aware, that it currently stores all messages in RAM, so every restart will take forever to load your rooms and it may run out of RAM at some point. Storing messages in some database will come at some point. Also, a lot of menus may lead nowhere, since those are just placeholders for me atm.
Recently, I tweaked Element-web to feature a few changes similar to SchildiChat for Android.
For now, it's probably best seen rather as a proof-of-concept than a finished product, as there are still some layout bugs, and no settings available for the added features (I know some people prefer separate lists for direct and group chats).
I consider it usable though.
Particular changes compared to upstream Element-web include:
A common section for groups and direct chats in the overview
Message bubbles
Bigger items in the room overview
A different dark theme, similar to SchildiChat for Android
I don't know how much I will work on this in the future, but I figured it might be interesting to share either way. Maybe even someone with more web-development skills than me might want to help improving it :)
The current version of SchildiChat-Desktop is available for Desktop here, and I host the web variant here.
If you want to build it yourself, check out this repo.
I wrote a Wake-on-LAN bot to wake up hosts by sending a matrix message. It is configurable with multiple hosts and has a list of users per host who are allowed to wake it up. It's using the matrix-rust-sdk, source is available over at https://git.jcg.re/jcgruenhage/matrix-wol, and if anyone has questions, feel free to join #matrix-wol:jcg.re.
When I asked what this is used for:
I have stuff on my workstation that I need access to most of the time, but keeping it running uses too much power (but I did it anyway so far), this is so that I can suspend it when I leave but can still power it on when I need something from there on the got
I was invited to the German Podcast MacMittwoch (no, it's not only about Macs) to talk about Bridges and Bots in Matrix. It was a very interesting and funny round.
This is a script I've created for use with MSC2545. It allows easy uploading of emoji packs to Matrix rooms. Feel free to check it out on Gitea, or join the project room #matrix-emoji-upload:blob.cat if you have any questions/comments/issues.
Here we reveal, rank, and applaud the homeservers with the lowest ping, as measured by pingbot, a maubot that you can host on your own server. Join #ping:maunium.net to experience the fun live, and to find out how to add YOUR server to the game.
Rank
Hostname
Median MS
1
imninja.net
466.5
2
midov.pl
531
3
mdpnd.ch
540
4
chatcloud.net
569
5
elcyb.org
801
6
fab.network
967
7
conduit.rs
1168
8
envs.net
1863.5
9
blob.cat
2660
10
aragon.sh
2743.5
That's all I know 🏁
See you next week, and be sure to stop by #twim:matrix.org with your updates!
Today we have released Synapse 1.21.2, which fixes a couple of minor bugs that crept into the previous release. Full details are below.
Separately, we are advising any administrators who have not yet upgraded to Synapse 1.21.0 or later to do so as soon as possible. Previous versions of Synapse were vulnerable to a cross-site-scripting (XSS) attack; the bug was fixed in Synapse 1.21.0 with PR #8444.
The changelog for 1.21.2 is as follows:
Synapse 1.21.2 (2020-10-15)
Debian packages and Docker images have been rebuilt using the latest versions of dependency libraries, including authlib 0.15.1. Please see bugfixes below.
Bugfixes
Fix rare bug where sending an event would fail due to a racey assertion. (#8530)
An updated version of the authlib dependency is included in the Docker and Debian images to fix an issue using OpenID Connect. See #8534 for details.
Add experimental support for sharding event persister. (#8294, #8387, #8396, #8419)
Add experimental prometheus metric to track numbers of "large" rooms for state resolutiom. (#8425)
Add prometheus metrics to track federation delays. (#8430)
Fix messages not being sent over federation until an event is sent into the same room. (#8230, #8247, #8258, #8272, #8322)
We've also made some improvements to SSO and added new admin APIs.
Get the new releases from any of the usual sources mentioned at https://github.com/matrix-org/synapse/blob/master/INSTALL.md. 1.21.1 is on github here
The changelog for 1.21.1 is as follows:
Synapse 1.21.1 (2020-10-13)
This release fixes a regression in v1.21.0 that prevented debian packages from being built.
It is otherwise identical to v1.21.0.
Synapse 1.21.0 (2020-10-12)
No significant changes since v1.21.0rc3.
As noted in v1.20.0, a future release will drop support for accessing Synapse's Admin API under the /_matrix/client/* endpoint prefixes. At that point, the Admin API will only be accessible under /_synapse/admin.
Synapse 1.21.0rc3 (2020-10-08)
Bugfixes
Fix duplication of events on high traffic servers, caused by PostgreSQL could not serialize access due to concurrent update errors. (#8456)
Internal Changes
Add Groovy Gorilla to the list of distributions we build .debs for. (#8475)
Synapse 1.21.0rc2 (2020-10-02)
Features
Convert additional templates from inline HTML to Jinja2 templates. (#8444)
Bugfixes
Fix a regression in v1.21.0rc1 which broke thumbnails of remote media. (#8438)
Do not expose the experimental uk.half-shot.msc2778.login.application_service flow in the login API, which caused a compatibility problem with Element iOS. (#8440)
Fix malformed log line in new federation "catch up" logic. (#8442)
Fix DB query on startup for negative streams which caused long start up times. Introduced in #8374. (#8447)
Synapse 1.21.0rc1 (2020-10-01)
Features
Require the user to confirm that their password should be reset after clicking the email confirmation link. (#8004)
Add an admin API GET /_synapse/admin/v1/event_reports to read entries of table event_reports. Contributed by @dklimpel. (#8217)
Consolidate the SSO error template across all configuration. (#8248, #8405)
Add a configuration option to specify a whitelist of domains that a user can be redirected to after validating their email or phone number. (#8275, #8417)
Add experimental support for sharding event persister. (#8294, #8387, #8396, #8419)
Add the room topic and avatar to the room details admin API. (#8305)
Add an admin API for querying rooms where a user is a member. Contributed by @dklimpel. (#8306)
Add uk.half-shot.msc2778.login.application_service login type to allow appservices to login. (#8320)
Add a configuration option that allows existing users to log in with OpenID Connect. Contributed by @BBBSnowball and @OmmyZhang. (#8345)
Add prometheus metrics for replication requests. (#8406)
Support passing additional single sign-on parameters to the client. (#8413)
Add experimental reporting of metrics on expensive rooms for state-resolution. (#8420)
Add experimental prometheus metric to track numbers of "large" rooms for state resolutiom. (#8425)
Add prometheus metrics to track federation delays. (#8430)
Bugfixes
Fix a bug in the media repository where remote thumbnails with the same size but different crop methods would overwrite each other. Contributed by @deepbluev7. (#7124)
Fix inconsistent handling of non-existent push rules, and stop tracking the enabled state of removed push rules. (#7796)
Fix a longstanding bug when storing a media file with an empty upload_name. (#7905)
Fix messages not being sent over federation until an event is sent into the same room. (#8230, #8247, #8258, #8272, #8322)
Fix a longstanding bug where files that could not be thumbnailed would result in an Internal Server Error. (#8236, #8435)
Upgrade minimum version of canonicaljson to version 1.4.0, to fix an unicode encoding issue. (#8262)
Fix longstanding bug which could lead to incomplete database upgrades on SQLite. (#8265)
Fix stack overflow when stderr is redirected to the logging system, and the logging system encounters an error. (#8268)
Fix a bug which cause the logging system to report errors, if DEBUG was enabled and no context filter was applied. (#8278)
Fix edge case where push could get delayed for a user until a later event was pushed. (#8287)
Fix fetching malformed events from remote servers. (#8324)
Fix UnboundLocalError from occurring when appservices send a malformed register request. (#8329)
Don't send push notifications to expired user accounts. (#8353)
Fix a regression in v1.19.0 with reactivating users through the admin API. (#8362)
Fix a bug where during device registration the length of the device name wasn't limited. (#8364)
Include guest_access in the fields that are checked for null bytes when updating room_stats_state. Broke in v1.7.2. (#8373)
Fix theoretical race condition where events are not sent down /sync if the synchrotron worker is restarted without restarting other workers. (#8374)
Fix a bug which could cause errors in rooms with malformed membership events, on servers using sqlite. (#8385)
Fix "Re-starting finished log context" warning when receiving an event we already had over federation. (#8398)
Fix incorrect handling of timeouts on outgoing HTTP requests. (#8400)
Fix a regression in v1.20.0 in the synapse_port_db script regarding the ui_auth_sessions_ips table. (#8410)
Remove unnecessary 3PID registration check when resetting password via an email address. Bug introduced in v0.34.0rc2. (#8414)
Improved Documentation
Add /_synapse/client to the reverse proxy documentation. (#8227)
Add note to the reverse proxy settings documentation about disabling Apache's mod_security2. Contributed by Julian Fietkau (@jfietkau). (#8375)
Improve description of server_name config option in homserver.yaml. (#8415)
Deprecations and Removals
Drop support for prometheus_client older than 0.4.0. (#8426)
Internal Changes
Fix tests on distros which disable TLSv1.0. Contributed by @danc86. (#8208)
Simplify the distributor code to avoid unnecessary work. (#8216)
Remove the populate_stats_process_rooms_2 background job and restore functionality to populate_stats_process_rooms. (#8243)
Clean up type hints for PaginationConfig. (#8250, #8282)
Track the latest event for every destination and room for catch-up after federation outage. (#8256)
Fix non-user visible bug in implementation of MultiWriterIdGenerator.get_current_token_for_writer. (#8257)
Switch to the JSON implementation from the standard library. (#8259)
Add type hints to synapse.util.async_helpers. (#8260)
Simplify tests that mock asynchronous functions. (#8261)
Add type hints to StreamToken and RoomStreamToken classes. (#8279)
Change StreamToken.room_key to be a RoomStreamToken instance. (#8281)
Refactor notifier code to correctly use the max event stream position. (#8288)
Here's your weekly spec update! The heart of Matrix is the specification - and this is modified by Matrix Spec Change (MSC) proposals. Learn more about how the process works at https://matrix.org/docs/spec/proposals
In terms of Spec Core Team MSC focus for this week, we're going to be keeping the same three MSCs as last week, as their review is still a work in progress. As a reminder, those are MSC2774 (widget URL template parameters), MSC2765 (widget avatars), and MSC2790 (modal widgets).
Dept of Servers 🏢
Dendrite goes beta
Dendrite is a next-generation homeserver written in Go
It aims to be an efficient, reliable and scalable alternative to Synapse.
We encourage early adopters to try it out starting with v0.1.0 in Monolith/Postgres mode.
Dendrite supports a large amount of the Matrix spec including:
All room versions
E2E encryption (but not cross-signing)
Federation
and many others!
We'll be hard at work in the coming weeks ironing out any issues that crop up as Dendrite enters the global
federation of Matrix servers. At present, Dendrite has not been optimised for memory/CPU usage, nor does it
fully support sharding, so there is still much scope to improve the already impressive resource usage whilst
This week I worked on a new feature: the Admin Room. This is a room that is automatically created for the first user of a new homeserver. This room will be used to send warnings to server admins in the future and can be used to control Conduit (like querying information, running cleanup, banning servers, hiding public rooms or restarting Conduit). Power levels can be used to control who in the room has access to which commands. The admin room will work over federation, so it's easy to help someone fix his server.
Other news:
Federation is now disabled by default and can be enabled in the config
Bug with typing notifications is fixed
Thanks to everyone who supports me on Liberapay or Bitcoin!
This week we put out v1.21.0rc3, which fixes a duplicate messages bug. We expect the full release to go out early next week.
After a long and sometimes painful journey we plan to run sharded event persisters on matrix.org from Monday. All being well we will start running background processes on their own worker to free up the main process.
These two projects combined should noticeably improve performance of matrix.org and any large scale deployments.
Aside from that we are continuing to work on room knocking as a feature and have been considering ways to reduce load attributable to state resolution.
The native Gitter <-> Matrix bridge is underway and we're working on virtual users which is the first piece to making the bridge feel native. You can see what this will look like in this ominous and exciting tweet: https://twitter.com/gitchat/status/1314252991705292800
There is also a GitLab epic you can track which breaks down some of the tasks and holds more details of what we're thinking of for the bridge.
Asgardians rejoice, for Bifrost development resumed this week! We've worked extremely hard this week to improve general gateway performance, edge case bugs and basically plowing on with the project. A 0.2.0 release will shortly be due with the new changes, and matrix.org is already running the latest and greatest. You can checkout the project over at https://github.com/matrix-org/matrix-bifrost
Former Fractal GSoC intern Alejandro Dominguez 😎️ got his Integrate matrix-sdk (I) merge request in “Ready for review” state. That’s a +3910/-5439, 38 commits diff‼️ poljar, who is the main contributor of matrix-rust-sdk, already had a look and provided some insights, but given 😱️ the sheer size of the changeset, the moar 👀️ we can get on it the better.
FluffyChat now runs on native Linux desktop (x86).
You can download Linux tarballs from the CI and run them on any system which has sqlite3 installed (which all distros may have). If you have libolm3 installed, you can also use e2ee.
Oh and by the way. Its NOT electron or any html5 stuff! Its a native Linux app.
We are working on packaging solutions like snap and Flatpak. 😊
Nheko is a desktop client using Qt, Boost.Asio and C++17. It supports E2EE (with the notable exception being device verification for now) and intends to be full featured and nice to look at
This week we finally cleaned up the remaining parts of Chethans GSoC work and merged it. This means Nheko now has partial support for cross-signing. You can either start the verification from another client or when viewing the profile of a user. There are a few things still missing though:
Nheko does not use the verification status at all at the moment. So while you can verify your master key and let others verify your master key, from Nhekos perspective there is not much benefit yet. You will however show up with a green checkmark in other clients.
While nheko supports verifying your own master key and after that will also let others verify your master key, it does not yet download the self and user signing keys. This means you won't be able to upload cross-signing signatures for your own devices and other users master keys yet. I'll see if I can implement in the next weeks or so (since literally only the private key download or sharing is missing).
Nheko can't bootstrap cross-signing yet. This means you need to bootstrap it from Element or another client once. That will probably take a bit until this is complete.
The UX is still WIP. Currently it shows a lot of unnecessary buttons, that are a bit confusing as well as not enough green checkmarks, so that needs some work.
Other things that happened in the mean time or are work in progress:
Decryption errors should be reduced by a bit now. This is still work in progress though. With device trust landed now, we should be able to do automatic key requests, sharing and key backup soon.
Lurkki is currently cleaning up the design of the built in video player.
manu_kamath is improving the design when showing images at the same time.
LorenDB has been updating our screenshots and working on an Esperanto translation.
trilene has been ever busy improving edge cases around the Voip support in Nheko.
So far Hacktoberfest seems to be going well with quite a few people trying to clean up some of the rougher edges in Nheko. If you are using Nheko and think some things could be better, why not try to fix it yourself? October is the perfect time for that!
Featurework of this cycle is also slowly nearing its end. Once cross-signing, voip and the new event store are stable, we plan to improve the UX a bit more as well as some other annoyances and maybe we can do a new release then! A nice and spooky Hacktober everyone!
Fixed a race during cross-signing key upload at registration time
Clarified when you have unsaved changes in profile settings
Finally, the improved widget support is looking very exciting. Here is a design grab to give you an idea of what to expect. Note this is not a real Element screen shot, the base functionality is there, but the look and feel of the final version is subject to change.
This week, Hydrogen gained better caching (and a little over-eager on Safari), room list filtering, a grid layout to show up to 6 rooms simultaneously (see screenshot) and work is well on its way for url-based navigation within the app.
also adding the screenshot on iOS that I didn't get in last week, showing the full range of display formats supported 🙂
The app also received some visual polish, thanks to Nad, our designer.
This week, I have improved the scoring rubric, so that the verdict given to you by the tester more accurately reflects the likelihood of connection establishment.
I have also added more hints on what the verdicts mean.
Finally, I have added workarounds to support Chromium browsers that decided to break their WebRTC API so that they could pedantically rename ip to address. In any case, it now seems to be on par with Firefox.
The VoIP tester is now roughly 'usable' but please note that IPv6 support is totally untested (I don't have IPv6) — it is also suspected that some browsers won't try IPv6 anyway.
There are also some more features on the wish list, such as screenshot safety and extra help when things go wrong.
Versions 3.2.0 and 3.2.1 of libolm have been released. 3.2.0 supports fallback keys (MSC2732) in the C library and the JavaScript binding, and includes several JavaScript/TypeScript fixes and improvements. 3.2.1 was just a fix to the TypeScript definition file.
Dept of SDKs and Frameworks 🧰
Ruma
Ruma is a Rust project to create a comprehensive set of APIs for Matrix. Previously there was a Ruma homeserver project.
This week, q-b implemented moderation policy events, bringing us to full compatibility with r0.6.1 of the client-server API. iinuwa added the only endpoint we were missing from the appservice API. Additionally, I improved Ruma's JSON canonicalization, making it both simpler and more efficient.
Due to twoissues regarding future-compatibility, we're still a while away from our next set of releases, but we're working on it!
ObjMatrix (GitHub) is a new Matrix client library written in modern Objective-C for ObjFW. Because it uses ObjFW, it is not limited to Apple platforms, and instead is extremely portable and should run on basically everything.
This is currently in its very early stages and is intended to be suitable to develop bots and clients with very soon. Being suitable to develop bridges with it is another goal for later.
Since ObjFW also works on platforms that are usually hard to support or port software to (e.g. MorphOS), this will hopefully also bring clients for these less mainstream operating systems. I'm especially hopeful about MorphOS here, since ObjFW already runs quite well there (parts of it are included with the OS even!), and hardware on which MorphOS runs on is usually not powerful enough to run Element Web. And eventually, I will want to have a Matrix client on my Amiga, too 😉 (which this should enable).
This currently does not have a decicated Matrix room yet, so all discussions about it currently happen in #objfw:nil.im. So please feel free to join there and follow along development. And contributions are of course very welcome!
We’ve put together a write up on how to deploy a Noteworthy Hub (transparent TLS proxy) in order to make it easy to run a federation capable matrix home server behind a firewall or NAT: https://noteworthy.tech/hub
Dept of Ping 🏓
Here we reveal, rank, and applaud the homeservers with the lowest ping, as measured by pingbot, a maubot that you can host on your own server. Join #ping:maunium.net to experience the fun live, and to find out how to add YOUR server to the game.
Rank
Hostname
Median MS
1
helderferreira.io
487
2
heitkoetter.net
627
3
asra.gr
802
4
conduit.rs
1178
5
matrix.thedisco.zone
1275.5
6
shortestpath.dev
1803
7
lelux.net
2419
8
elcyb.org
2685
9
test.zemos.net
2800
10
blob.cat
2882
That's all I know 🏁
Thanks anoa for TCB* the last two weeks! Was fun to be the one to read TWIM for myself. :D
See you next week, and be sure to stop by #twim:matrix.org with your updates!
We’re very excited to announce that Dendrite, the next-generation Matrix homeserver from the core Matrix team, is at last exiting alpha development and entering beta testing!
The path we’ve taken to get here has been quite a curious one, and it’s worth recapping to give context on why it’s taken reality a little while to catch up with the dream. :)
The Dendrite project has its roots in 2016 as Dendron: an attempt to write a next-generation homeserver in Golang rather than Python, in order to benefit from Go’s stronger typing, ease of profiling (no twisted stack-shredding via deferredInlineCallbacks), multithreading and faster GC performance. The idea for Dendron was to do a strangler pattern rewrite of Synapse - where we’d insert Dendron in front of Synapse as a load balancer, and incrementally replace Synapse’s API endpoints with ones implemented by Dendron.
However, as the project started to progress, it became clear that this was going to end up with many of Synapse’s architectural choices being baked into the project - particularly the DB schema and data flow architecture, such that the new endpoints could interoperate with the existing Python ones. We got as far as putting Dendron live on matrix.org and moving some of the login/registration APIs over to it… but then work fizzled out due to Synapse demanding more urgent attention as traffic grew on Matrix.org, combined with concerns about whether Dendron was the right approach in general.
So, towards the end of 2016 (after the rush to launch VectorRiot Element that summer), we went back to the drawing board to devise Dendrite—“Dendron done right!”—as opposed to Dendron, which in retrospect was Dendrite done wrong. ;) The new vision was:
Build a massively horizontally scalable architecture, such that large Matrix deployments like matrix.org and big government deployments could run smoothly without the constant scalability headaches we were seeing at the time with Synapse
Do so by splitting the server into well-defined microservice components, each of which could independently horizontally scale, each with its own DB (if desired)
Connect the components together with a set of append-only logs via Kafka or similar, easily letting components shard and maintain their databases from the logs, allowing rolling upgrades, possibly schema upgrades, and all sorts of other niceties. The logs effectively become a primary source of truth rather than putting all the onus on a massive monolithic ever-growing database
Rather than Dendron’s top-down approach, instead Dendrite started bottom-up with the very hardest bit: gomatrixserverlib, a standalone Go library implementing the state resolution algorithms and performing federation requests (such that it might also someday be used as a general purpose way to add Matrix federation support to an existing Go codebase).
Then we started building out the various components to implement the various services, starting with the roomserver (the service which models the history and state of one or more rooms in the server), then the syncserver (the service which implements the /sync API to let clients receive messages), etc. We even implemented a simplified in-memory version of Kafka named naffka—useful for glueing together the microservice components when running them all within a single binary.
Things were looking pretty positive by the summer of 2017: we had the server sending/receiving messages, federating with Synapse, and looking tantalisingly close:
We just sent the first ever synapse->dendrite federated traffic, including full dendrite media API (thumbnailing, fed, etc)!!! :D :D :D pic.twitter.com/sBcM2jMAr6
In the ensuing uncertainty, the two lead developers (Mjark & Kegan) went to work elsewhere
Meanwhile, Matrix uptake was starting to explode and Synapse was failing to scale to handle the traffic on matrix.org (and elsewhere)
At first, having formed what would become New Vector (now Element) to keep the rest of the core team hired, we pushed to see if we could get Dendrite finished fast enough to replace Synapse, with Erik & richvdh jumping over from Synapse to pick up the remaining work. However, it became clear that we urgently needed a quicker solution to address all the overloaded Synapses out there, and so they swung back to focus on improving Synapse (taking inspiration from some of the design of Dendrite - e.g. offloading endpoints onto worker processes connected via replication streams, and using OpenTracing to debug traffic as it flows over the various services).
At this point, Dendrite maintenance was in effect valiantly taken over by the community, with Brendan and later Anoa keeping the ball going in 2017, joined by APWhitehat in GSoC 2018 and cnly in GSoC 2019. The fact that Dendrite is now here today is thanks in no small part to their work to keep the project alive in its “wilderness years” between Sept 2017 and Dec 2019.
Meanwhile, it became clear that we were overdue getting Matrix itself out of beta - and the last thing we wanted to do was to split and dilute the implementation work of Matrix 1.0 over both Synapse and Dendrite - so we consciously made the decision to focus all our effort on Synapse for solving the remaining bugs and challenges.
Then, in July 2019, Matrix and Synapse exited beta, and we finally started to see light at the end of the tunnel. In October we started dusting off Dendrite again - looking to use it as a relatively simple and flexible codebase for experimenting with Peer-to-Peer Matrix, not least because being Go it can compile to WebAssembly and run clientside, and because even though Dendrite was originally built with massive deployments in mind, it turns out the elastic scaling means it can also scale down pretty small too—as a part of the iOS P2P demo, we’ve even ran full Dendrite homeservers on iPhones embedded into Element iOS! :)
In Dec 2019, we finally got to the point where Element could fund full-time dedicated development on Dendrite once again, with Neil Alexander joining the project and focusing fulltime on getting Dendrite out of alpha and getting it working for P2P and embedded usage (adding libp2p as a federation transport, and adding SQLite support) - and in Jan 2020 we got Dendrite successfully running clientside in a WASM service worker (just in time for FOSDEM!). Then, in Feb 2020, Kegan returned to the project to work fulltime on Dendrite - and the race began in earnest to get Dendrite ready for beta!
Here’s a pretty picture courtesy of GitHub to visualise the progress:
Throughout 2020 there’s been a huge amount of stabilisation work and polish:
Refactoring much of Dendrite’s foundation to make the codebase more maintainable
Created all-new user server, key server, signing key server microservices
Moving some work from existing microservices (ultimately superseding the former currentstateserver, publicroomsapi and typingserver microservices altogether)
Developing new testing infrastructure:
Complement - our brand new Golang Matrix integration test harness
Are We Synapse Yet - an aggregator which parses sytest/complement output to compare how close Dendrite is to passing
All the Matrix 1.0 work - particularly state res v2 & room version support
User interactive authentication (and implemented on various ‘sudo’ endpoints e.g. deleting devices and changing passwords)
Respecting server ACLs
Rejecting / soft-failing events properly
Support for database schema upgrades
... which brings us at last to the present day (Oct 2020), as we declare Dendrite sufficiently stable that we consider it ready for beta testing!
In practice, this means **Dendrite is now ready for experimentation by adventurous Matrix sysadmins. It is NOT ready for production usage yet, but we need folks to test it and help us iron out the remaining bugs! **Please do not trust it with sensitive data yet, and we don’t recommend trying to run it at scale yet as we haven’t done any serious optimisation work yet.
That said, we do provide the following guarantees:
We’re providing versioned releases from here on in, beginning with 0.1.0
We don’t expect any major breaking changes to the config or architecture before 1.0
Ready for early adopters to try running Dendrite without experiencing ~daily breaking churn
The database schema is now stable and will upgrade itself going forwards - your database should now be here to stay! (assuming we don’t hit any nasty data loss bugs during beta)
In terms of comparison with Synapse, the main things you should get excited about are:
Dendrite aims to provide an efficient, reliable and scalable alternative to Synapse:
Efficient: A small memory footprint with better baseline performance than an out-of-the-box Synapse
Scalable: can run on multiple machines and eventually scale to massive homeserver deployments
This means significantly less memory usage than Synapse (depends on joined rooms, often between 50MB - 400MB resident memory) - although we haven’t tuned this at all yet!
All-new database model, where every microservice instance has its own database tables, letting them scale arbitrarily wide
The ability to efficiently use all your available CPU cores without needing to split into separate processes, thanks to Go and our extensive use of goroutines. No more Python global interpreter lock! :)
We’re not feature complete yet: sytest reports 56% CS API coverage and 77% Federation coverage. NB: these are always going to be underestimates of how much Dendrite actually performs due to how the tests are spread out, in actuality it’s likely more 70% CS, 95% Fed.
No read receipts, membership lazy-loading, presence, push notifications, search, event context, key backups, cross-signing. See changelog for full limitations.
Not battle-tested in the wild by many people (there are probably only ~10 dendrites on the open network today!) - so there’s likely to be a broad spectrum of bugs at first.
Clients that require more exotic features, like lazy loading, may not behave properly yet
Please use Postgres rather than SQLite wherever possible—it’s faster and has fewer issues regarding concurrency (some requests on SQLite Dendrites may 500 with ‘database is locked’ - though we’ve worked hard to eliminate most of these)
Dendrite can run in either “monolith” or “polylith” mode. In monolith, all the microservices are linked into a single binary - and we recommend running in this configuration wherever possible for now. Monolith mode is extremely capable as it is and has fewer moving parts for things to go wrong and will be the right choice for the majority of beta deployments!
Whilst Dendrite is nearly 100% federation compatible, there may still be situations where it will split-brain and disagree with the current room state that Synapse has calculated. We expect these issues to resolve as we get more user feedback.
Architecture-wise, this is what Dendrite looks like under the hood today:
Read receipts. It’s a major missing feature and impacts UX significantly.
100% Federation coverage (according to sytest). It’s crucial that Dendrite instances play nicely with other servers. This will be the best metric we have for asserting that we are just as capable as Synapse at the fed level.
Optimisation—Dendrite has not been optimised yet for speed or resource utilisation!
We plan to add benchmarks which will stress test different microservices in the presence of many different scaling factors (number of users, number of rooms, size of room, number of devices per user, number of sync requests, etc). This will hopefully allow us to identify early on bottlenecks and slow algorithms
Good old fashioned pprof with known slow scenarios to see what’s consuming CPU/memory and fixing issues ad-hoc (which we’ve already done a bit of pre-beta). This may involve adding additional in-memory caches, with a healthy respect for the complexities it may introduce (which Synapse has been bitten by)
We plan to add first class feature flag support for experimental MSCs—experimentation is one thing which makes Dendrite notably different from Synapse, and supporting it more thoroughly going forwards will be important. This may mean adding additional hooks; potentially a dedicated microservice to cleanly separate experiments, we don’t know yet
P2P work will continue with vigour now we have a working, featureful, and relatively stable HS to embed and play with
Longer term, it’s pretty hard to say right now when we expect to exit beta (it took Synapse 5 years to exit beta, after all ;) - but obviously we’ll need Dendrite to have parity with Synapse and have no known serious bugs.
Finally: you’re probably wondering what this means for Synapse. Synapse is here to stay - with tens of thousands of deployments around the world serving tens of millions of users. The majority of the core team is still focused on improving and optimising Synapse, and we’ll be keeping improving it for the foreseeable.
However, we’ll certainly be experimenting with new stuff on Dendrite first - whether that’s P2P, portable accounts, new-style communities, peeking etc. We expect Synapse to be the stable long-term-supported solution, while Dendrite (particularly while in beta) will be the more unstable and experimental platform. In the longer term we’ll provide ways of migrating from Synapse to Dendrite however (probably via portable accounts), and perhaps in future new deployments may choose to use Dendrite - a bit like you might choose to use nginx rather than Apache for a new web server these days. But this will be a long transition—meanwhile we expect to see more and more next-generation homeservers like Conduit, Mascarene or Construct coming of age too.
So, there you have it. If you’re an intrepid sysadmin please spin up a Dendrite and start filing bugs! :)
— Matthew, Neil Alexander, Kegan and the whole Matrix team.
Here’s the official changelog:
Client-Server API Features
Account registration and management
Registration: By password only.
Login: By password only. No fallback.
Logout: Yes.
Change password: Yes.
Link email/msisdn to account: No.
Deactivate account: Yes.
Check if username is available: Yes.
Account data: Yes.
OpenID: No.
Rooms
Room creation: Yes, including presets.
Joining rooms: Yes, including by alias or ?server_name=.
Event sending: Yes, including transaction IDs.
Aliases: Yes.
Published room directory: Yes.
Kicking users: Yes.
Banning users: Yes.
Inviting users: Yes, but not third-party invites.
Forgetting rooms: No.
Room versions: All (v1 - v6)
Tagging: Yes.
User management
User directory: Basic support.
Ignoring users: No.
Groups/Communities: No.
Device management
Creating devices: Yes.
Deleting devices: Yes.
Send-to-device messaging: Yes.
Sync
Filters: Timeline limit only. Rest unimplemented.
Deprecated /events and /initialSync: No.
Room events
Typing: Yes.
Receipts: No.
Read Markers: No.
Presence: No.
Content repository (attachments): Yes.
History visibility: No, defaults to joined.
Push notifications: No.
Event context: No.
Reporting content: No.
End-to-End Encryption
Uploading device keys: Yes.
Downloading device keys: Yes.
Claiming one-time keys: Yes.
Querying key changes: Yes.
Cross-Signing: No.
Misc
Server-side search: No.
Guest access: Partial.
Room previews: No, partial support for Peeking via MSC2753.
Third-Party networks: No.
Server notices: No.
Policy lists: No.
Federation Features
Querying keys (incl. notary): Yes.
Server ACLs: Yes.
Sending transactions: Yes.
Joining rooms: Yes.
Inviting to rooms: Yes, but not third-party invites.
Leaving rooms: Yes.
Content repository: Yes.
Backfilling / get_missing_events: Yes.
Retrieving state of the room (/state and /state_ids): Yes.
It's true! Element has acquired Gitter from GitLab and will be implementing
Gitter's current chat features in Matrix, before rebuilding Gitter as a Matrix
client! Before all that however, the first step is to build a proper, modern
bridge between the two networks, replacing the old one that's been around for
years.
Here's your weekly spec update! The heart of Matrix is the specification - and this is modified by Matrix Spec Change (MSC) proposals. Learn more about how the process works at https://matrix.org/docs/spec/proposals.
In terms of Spec Core Team MSC focus for this week, after dropping off MSC2414 in the FCP bucket, we're heading back for another big swing at widgets. MSC2774 (widget ID URL parameter), MSC2765 (widget avatars) and MSC2790 (modal widgets) are the focus for this week 🙂
being totally shook up about the Gitter announcement for a good part of the week, I completed the work on MSC2312 (it's about Matrix URIs, ICYMI) and it hopefully won't be long before it becomes the actual standard to share Matrix coordinates in popular web browsers. Ok, who am I kidding - before Matrix clients get on with adoption.
This will allow people to post links to Matrix rooms/messages/users and when clicked will open right in your favourite Matrix client. Super convenient and great for adoption!
Dept of P2P 👥
iOS P2P Demo
Dendrite is a next-generation homeserver written in Go. It is currently serving as the basis for peer-to-peer Matrix experiments
Build 38 of the iOS P2P Demo, as built using Element iOS and Dendrite, has been submitted to TestFlight and will hopefully be available for testers shortly (pending Apple approval)! It features lots of updates in the Dendrite backend which should hopefully make it more reliable.
This week we put out a new release candidate -1.21.0rc2
Highlights include
Add experimental support for sharding event persister. (#8294, #8387, #8396, #8419)
Add experimental prometheus metric to track numbers of "large" rooms for state resolutiom. (#8425)
Add prometheus metrics to track federation delays. (#8430)
Fix messages not being sent over federation until an event is sent into the same room. (#8230, #8247, #8258, #8272, #8322)
Fix a regression in v1.21.0rc1 which broke thumbnails of remote media. #8438
Aside from that we are working on moving background processes away from the main process, actually getting the event persister sharding onto matrix.org and trying to improve Synapse stability generally.
Dendrite / gomatrixserverlib
Dendrite is a next-generation homeserver written in Go
Dendrite is nearing beta! Today we will be cutting a candidate 0.1.0rc1 version after a week of hunting and fixing bugs. We are on track to release version 0.1.0 next week, at which point we will be inviting people to try installing and using Dendrite!
Changes this week include:
Initial sync is fixed after a bug caused us to fall back on incremental sync
The Content-Type HTTP header is now handled properly when MIME-formatted
Internal API calls over HTTP in polylith mode now use their own HTTP client with higher timeouts
Dendrite now tries harder to find missing auth events, using fetcher workers
Dendrite no longer falls back on /state unnecessarily, which was the cause of a major memory leak and high CPU usage
Federation HTTP calls now include the User-Agent header
The event depth field is now ignored in the federation API
We now report the password change capability properly (thanks bn4t!)
Registration flows now include the completed field after a failure (thanks Lesterpig!)
A bug in the previous event updater in the roomserver has been fixed
A bug where we didn't check our own old verify keys when verifying event signatures is fixed
A bug where we didn't handle event ID domains being different to the event origin in earlier room versions has been fixed
If contributing to Dendrite sounds like something you would be interested in, please take a look at these issues and join us in #dendrite-dev:matrix.org! There's also #dendrite:matrix.org for general Dendrite chat and updates and #dendrite-alerts:matrix.org for release notifications and important alerts.
This week in Matrix Construct supports aarch64 (ARMv8) architectures. The experience has been phenomenal, with performance exceeding all expectations. Last week I wrote about all new vector code inside Construct using SSE through AVX-512 hardware acceleration in servers; that same code is now accelerated by SVE (Scalable Vector Extensions) on ARM architectures when you compile with clang.
This result is important: ARM virtual machines are offered at a significantly lower price compared to x86 from the same vendor. The systems are cheaper, require less power, but generally perform worse. The trick is to optimize the software for the weaker hardware. The benefit allows, for example, Matrix server hosts running Construct to make th eir profit margin from the lower TCO, getting more out of every computing cycle.
Currently it supports bridging messages, reactions and signal read receipts. End-to-bridge encryption also exists (mautrix-python does all the work there). The bridge can be linked as a secondary device and possibly even registered as the main device, but I didn't actually test registering yet. Setup instructions are currently somewhat non-existent, but it's mostly the same as my other bridges plus signald as a separate daemon.
mx-puppet-discord got updated to the newest discord.js version, meaning you have to update if you want to continue to operate it, due to discord having changed their gateway url!
mx-puppet-discord now also supports the intent stuff, so be sure to update by 7th oct
If you run mx-puppet-discord (like I do), make sure to update by October 7th or it will stop working!
Hey folks, I wanted to give another shoutout to say that we are still accepting PRs as part of hacktoberfest. Contributing 4 PRs will get you a T-Shirt (sadly not a Matrix one). Obviously, please ensure your PRs are meaningful (no copyright adjustments, typo fixes).
In the hope of expanding the number of people contributing to the matrix-appservice-slack repo I have spent a chunk of my morning improving the issue descriptions and labelling up issues. If you are interested in fixing a little annoyance with the slack bridge or just fancy writing some typescript see the good first issue label on the repo.
The matrix.org team are delighted to bring you the latest in Slack bridging technology. Do not let the
minor version bump fool you, this release is packed with the good stuff. The headline feature is that
our phase 1 encryption feature has landed and is free for users to experiment with. Head over to the
More browser compatibility work this week, making Hydrogen run IE11 on Windows 7, and on Safari on macOS and iOS (still with some caveats). Also fixed several bugs:
fix for unable to open session after a synapse bug manifested itself
prevent the app locking up when you start the app with previously unsent messages
fix sync errors being reported as "null" in the banner
handle timeout during initial sync (important for large accounts) (although I have seen 1 report that this still isn't fixed, please report if you can't login with a large account)
Element Android: Version 1.0.8 is now available on the stores, it fixes issues with verification and PIN code among other issues (see https://github.com/vector-im/element-android/releases/tag/v1.0.8 for more details). Now we are working on improving performance when sending messages to rooms, and also improving global UX, especially of the home (rooms list). Search messages (in clear rooms for the moment) is coming soon, and it will be also possible to filter the room members list.
We will also spend some time on the new Android SDK, https://github.com/matrix-org/matrix-android-sdk2, which is for the moment a quick extract of what we have in Element Android. We have to take care of it as a real product now: document it properly, set up CI, export Javadoc, develop a sample app, etc.
Element for Nextcloud v0.6.11 has been released this week. The new version comes with various bug fixes, dependency upgrades, and an upgrade to Element Web v1.7.8. The version is also compatible with Nextcloud 20 which is being released soon.
Over the past couple of weeks, we've received PRs for all of the remaining federation endpoints, and all but one have already been merged!
Now that the end is in sight, we're turning our focus elsewhere. We're working on cleaning up and fixing a few bugs in our event signing code and soon will create tracking issues for filling out the Identity Service API.
All of these users are Telegram/Discord users that have been brought into Matrix over the last 30 days. This doesn't appear to be a temporary spike either: over the last 8 weeks t2bot.io has been hovering at 900-950 thousand monthly active users, up from 600-700 thousand. Record-setting traffic levels have also been achieved, with matrix.org being able to keep up for the first time in a long while.
Overall it's a good sign to see so many communities making the jump to Matrix and sticking around ❤️
I added zabbix-bot to my zabbix-matrix repo, which can get information about current problems from zabbix-server and send it to matrix user. https://github.com/progserega/matrix_zabbix
I've found that having your systems reporting in a room while you chat around
it can be really productive. Props to supporting yet another monitoring platform!
Dept of Interesting Projects 🛰️
Jitsi E2EE Calls using Olm
While 1-1 calls benefit from end-to-end encryption due to WebRTC, Jitsi group calls have always only benefitted from transport encryption.
A while ago Jitsi announced that they were adding E2EE to Jitsi. But did you know that it's using Matrix's Olm encryption under the hood? It's currently available as an experimental feature on https://meet.jit.si!
Dept of Ping 🏓
Here we reveal, rank, and applaud the homeservers with the lowest ping, as measured by pingbot, a maubot that you can host on your own server. Join #ping:maunium.net to experience the fun live, and to find out how to add YOUR server to the game.
Rank
Hostname
Median MS
1
fairydust.space
368
2
blob.cat
543
3
nuclearlimes.co.uk
580
4
nuclearlemons.uk
889
5
conduit.rs
912.5
6
mailstation.de
1075
7
matrix.org
1092
8
test.zemos.net
1123
9
shortestpath.dev
1251.5
10
chatcloud.net
1338.5
We also now have a room where the ping bots are only hosted on non-Synapse
servers! See the scoreboard below.
We are ridiculously excited to announce that Gitter is joining the Matrix ecosystem and will become the first major existing chat platform to switch to natively speaking Matrix!
If you’re reading this from the Gitter community and have no idea what Matrix is: we’re an open source project that provides an open protocol for secure, decentralised communication - effectively the missing real-time communication layer of the open Web. The open Matrix network has more than 20M users on it and is growing fast (adding another 1.7M or so with the arrival of Gitter!)
Gitter is easily one of the best developer community chat systems out there, used by the communities of some massive projects (Node, TypeScript, Angular, Scala etc) and is a custodian of huge archives of knowledge via their chat logs. Gitter is unique in specifically focusing on developers: their tagline is literally “Where developers come to talk” (unlike Slack, which has barely any community features - or Discord, with its ban on unofficial clients, where developers are a bit of an afterthought relative to the gamers). With Gitter natively joining Matrix, we’re super excited to see the global developer community converging on the open Matrix network - and Gitter’s community rooms should see a huge new lease of life as they’re properly made natively available to the wider network as first class citizens :)
We’ve always had a bit of a crush on Gitter ever since we ended up opposite each other in the exhibition hall at TechCrunch Disrupt Europe 2014 - particularly when they demoed us not only their sexy webapp but also their official IRC server bridge at irc.gitter.im :D Over the years we’ve been gently nudging them to consider fully embracing Matrix, but perhaps understandably they’ve been busy focusing on their own stuff. However, earlier this year, our friends at GitLab (who acquired Gitter in 2017) reached out to explore the opportunity of Gitter becoming a core part of Matrix rather than a non-core project at GitLab… and we’ve jumped on that opportunity to bring Gitter fully into Matrix.
In practice, the way this is happening is that Element (the company founded by the Matrix core team to fund Matrix development) is acquiring Gitter from GitLab, with a combined Gitter and Element dev team focusing on giving Gitter a new life in Matrix! You can read about it from the Element angle over on the Element blog.
Practically speaking, we have a pretty interesting plan here, which we’d like to be very transparent about given it’s a little unusual:
At first, Gitter will keep running as it always has - needless to say, we will be doing everything we can to delight the Gitter community and keep the service in good shape.
Then we’re going to build out native Matrix connectivity - running a dedicated Matrix homeserver on gitter.im with a new bridge direct into the heart of Gitter; letting all Gitter rooms be available to Matrix directly as (say) #angular_angular:gitter.im, and bridging all the historical conversations into Matrix via MSC2716 or similar. We will of course do this entirely as open source, just as Gitter itself is open source thanks to GitLab releasing it under the MIT license in 2017. The plan is to comprehensively document our progress as the flagship worked example case study of “how do you make an existing chat system talk Matrix.”
This will of course replace the old and creaky matrix-appservice-gitter bridge we’ve been running since 2016. Gitter users will also be able to talk to other users elsewhere in the open Matrix network - e.g. DMing them, and (possibly) joining arbitrary Matrix rooms. Effectively, Gitter will have become a Matrix client.
Now we come to the interesting bit. Gitter has some really nice features which are sorely lacking in Element today:
Instant live room peeking (less than a second to load the webapp into a live-view of a massive room with 20K users!!)
Seamless onboarding thanks to using GitLab & GitHub for accounts
Curated hierarchical room directory
Magical creation of rooms on demand for every GitLab and GitHub project ever
GitLab/GitHub activity as a first-class citizen in a room’s side-panel
Excellent search-engine-friendly static content and archives
KaTeX support for Maths communities
Threads!
...and we promise to do everything in our power to preserve and honour these features at all costs and continue to give the Gitter community the experience they’ve come to know and love.
However: in the medium/long term, it’s simply not going to be efficient for the combined Element/Gitter team to split our efforts maintaining two high-profile Matrix clients. Our plan is instead to merge Gitter’s features into Element (or next generations of Element) itself and then - if and only if Element has achieved parity with Gitter based on the above list - we expect to upgrade the deployment on gitter.im to a Gitter-customised version of Element. The inevitable side-effect is that we’ll be adding new features to Element rather than Gitter going forwards.
In practice, the main outcome in the end should be Element having benefited massively from levelling up with Gitter - and Gitter benefiting massively from all the goodies which Element and Matrix brings, including:
E2E Encryption
Reactions
Constantly improving native iOS & Android clients (which should be a welcome alternative to Gitter’s natives ones, which are already being deprecated)
VoIP and conferencing
All the alternative clients, bots, bridges and servers in Matrix
The full open standard Matrix API
Widgets (embedding webapps into rooms!)
...and of course participation in the wider decentralised Matrix network.
So, there you have it. It’s a new era for Gitter - and we look forward to reinvigorating Gitter’s communities over the coming months. We hope Gitter users will be blown away by the features arriving from Matrix… and we hope that Element users will be ecstatic with the performance and polish work that Gitter-parity will drive us towards. Imagine having guest access in Element that can launch and load a massive room in less than a second!
Finally, we would like to explicitly reassure the Gitter community again that we love and understand Gitter (it was one of the very first ever bridges we wrote for Matrix, for instance) - and we will be doing everything we can to not screw up our responsibility in looking after it. Please, please let us know if you have any concerns or if we ever fall short on this.
- Matthew, Amandine, and the whole Matrix, Element and Gitter teams.
Matthew and Amandine model 2014-vintage Matrix & Gitter swag in celebration :D
Bonus update - The Changelog Interview!
Sid Sijbrandij (CEO at GitLab) and Matthew had a chance to sit down with The Changelog to talk about Gitter's Big Adventure - so tune in to hear the story first hand! Warning: contains non-ironic use of the word "synergy" :D
Hello all, and welcome to this week's addition of This Week in Matrix!
Matrix is an open network protocol for secure,
decentralized communication on the web.
My name is Andrew (aka anoa), and I'm a Synapse developer at Element.
Thanks to Ben for letting me take over the reins of TWIM for this week! I'll
actually be doing the same for next week as well, so please adjust your
clocks to Anoa Nonstandard Time accordingly.
With that out of the way, let's jump right in!
Matrix Live 🎙
It's demos week again. This time around we've got the following lineup:
Michael shows off all the new widget goodies coming to Element Web!
Bruno shows off Hydrogen's new encrypted session backup support!
Ismail details the new room creation flow on Element iOS!
Jorik presents his work on revamping the UX of https://matrix.to that he completed for his second summer internship at Element!
Hubert fixes another class of failure-to-decrypt messages edge case with Device Dehydration!
Half-Shot closes off with the tale of Encrypted Bridges!
Don't forget that Matrix Live is also available in podcast form, if you're into that sort of thing. Search for "Matrix Live" wherever you get your podcasts.
Here's your weekly spec update! The heart of Matrix is the specification - and this is modified by Matrix Spec Change (MSC) proposals. Learn more about how the process works at https://matrix.org/docs/spec/proposals.
In terms of Spec Core Team MSC focus for this week, we've been rather busy with implementation, so we'll be continuing on with the same focus as last week. As a reminder, that's MSC2414 (making reason and score optional on reports).
Dept of Servers 🏢
Dendrite / gomatrixserverlib
Dendrite is a next-generation homeserver written in Go.
This week has mostly been spent trying to improve stability and to fix bugs ahead of the beta release, which is so far still planned to go ahead in the next two weeks.
Changes this week include:
Room version 6 is now the default for newly created rooms
Soft-fail of events that aren't allowed by the current room state is now implemented
Support for configuring old_verify_keys has been added to the Dendrite config
Correct formatting for signing key IDs is now enforced in the configuration
Initial support for peeking over federation (MSC2444) is in progress and it "even works!" (thanks Matthew!)
Federated joins will now continue being processed even if the client gives up on the join due to a HTTP timeout
Backoff code has been refactored a bit more, and now correctly affects device list syncing
/make_join now errors correctly if a federated user tries to join a room which all members have left
A bug where a single user could start multiple simultaneous federated joins to the same room has been fixed
Some initial (but unfinished) support for the /key/v2/query notary endpoint has been added
Signature verification has been updated to not fail if the event origin field is missing (although it still requires a signature from the domain of the sender field)
A number of places where we use SQL transactions have been updated with safe wrappers (thanks samcday!)
A couple of error codes on invite endpoints for room version 6 JSON violations have been fixed
Spec compliance has improved slightly for federation:
Client-Server APIs: 56%, same as last week
Server-Server APIs: 77%, up from 74% last week
As always, if contributing to Dendrite sounds like something you would be interested in, please feel free to join us in #dendrite-dev:matrix.org ! There's also #dendrite:matrix.org
This week we released 1.20.0 (and 1.20.1) highlights include shadow banning support and including unread message counts in the sync response. This will help client developers and is a precursor to improving notification support.
We’ve also been looking at adding monitoring to get a better sense of which rooms are most expensive from a state resolution perspective, we also want a better way to track federation lag.
Up next we’ll move all background tasks away from the main process and try it out on matrix.org, we are hoping for a 10-15% saving in CPU. Event persistence sharding, specifically the new stream token format is on hold slightly while we work on a nasty race condition on start up of the event persister. We hope to get back to the main sharding project next week.
This week in Matrix concludes a summer of Construct where several transformative rounds of optimization took place. I'd like to talk about these achievements and why they are important for
future directions.
Over the summer, Construct introduced new vector extensions to the project. As server software, our primary target is the datacenter which (for now) is dominated by x86 hardware. The latest features of x86 chips include AVX-2, AVX-512, and on-die GPU. These advancements are important because they help mitigate current limitations of hardware, such as the cubic relationship between a processor's frequency and its power consumption. These limitations mean that CPU cores aren't completing more cycles-per-second every iteration of their development -- they're not getting much faster.
The problem with threads is that they can introduce a lot of complications to a project. Construct is able to forego multi-threading as a network server because it is primarily IO-bound. The benefits to a single-thread design in both performance and simplicity cannot be overstated. This is why Construct stands to benefit the most from features which allow more work to be accomplished at every individual computing cycle.
Construct undertook several endeavors over the summer which directly leverage platforms featuring SSE, AVX, AVX-512, etc. As an added bonus, our approach is designed to effortlessly port to ARM's Scalable Vector Extensions (SVE) as it becomes available (inside datacenters too!). Our focus has been JSON, Unicode, and finally Base64. Detailed explanations for each of these will need to be discussed in their own posts, but in summary:
Matrix specifies a canonical form of JSON which is not necessarily the same as the JSON the server receives. Therefor it is imperative that Construct is liberal with what JSON it accepts and correct with its transformation into canonical JSON. Over the summer, a portion of Construct's canonical transform received some optimization to go beyond the default method of character-by-character read-modify-write. As seen in [1], a streaming hardware-accelerated transform now processes at least 16 characters at a time (with more possible) without forward branching except for the parts where transformation needs to occur. One of these transformations is UTF-16 to UTF-8 surrogate conversion, which leads into the second endeavor.
Construct introduced a completely branch-free Unicode toolset in [2]. Among the functions offered is a custom transform of UTF-16 surrogate pairs to UTF-8 sequences. Using the new vector registers, Construct can transform two UTF-16 surrogates in parallel to output two UTF-8 sequences, or two UTF-16 surrogates in a pair to output one UTF-8 sequence. Unfortunately, these specific functions were written at fixed vector widths, so more work needs to be done to really take advantage of the widest hardware. Each surrogate is 6 bytes, and a surrogate pair is 12 bytes; therefor we cannot make use of the last 4 bytes of a 16 byte vector. However, with a little more work this approach can be extended to a 64 byte vector, capable of decoding 5 surrogate pairs and 10 individual surrogates in parallel!
Professor Daniel Lemire recently published a paper about fast Base64 from hardware acceleration in [3]. This approach is extremely elegant on the 64-byte-wide AVX-512 system. Prior to Construct's implementation of this in [4], the Boost library base64 encoding and decoding took roughly 20 and 25 cycles per character respectively. Our implementation on the same system, an old system with only SSE2 (not even AVX-512!) yields 5 and 6 cycles per character!
All of this helps lay a foundation for Construct to introduce Federated Media Rooms sometime in the future. Currently, Construct stores media in a separate database. Recently there's been work on a separate branch at [5] which stores actual file block inside events using Base64. It is for this reason sub-cycle and branchless JSON parsing and Base64 encoding is essential for maximum performance. The result is worthwhile, as the latency for querying the media database is slower than parsing and decoding the event content already in-hand.
It's really exciting to see Homeserver development ramping up from all
angles, and nice that the protocol warts are slowly getting ironed out in the
process.
Thanks to Arkaniad, v2.7.0 of my Matrix Helm chart for Kubernetes is released with support for exporting Prometheus metrics. It pairs well with the Synapse Grafana dashboard.
The synapse docker image from AVENTER (https://www.aventer.biz), does support PowerPC (ppc64le) and ARM64 architecture now. But at the moment only under the docker tag "ppc". https://hub.docker.com/r/avhost/docker-matrix/tags?page=1&name=ppc We will be happy to get feedback.
As a Synapse developer, it's great to see the community making personal and
enterprise Matrix deployments more accessible!
Jump to events in timeline: When tapping on a reply and when tapping a matrix.to link
Display messages with up to 10 emotes or emoji bigger
New design for the chat list and message bubbles
Implement reactions
Implement password change
Implement deactivate user account
Fixes
Timeline randomly resorting while more history is being fetched
Automatically request history if the "load more" button is on the screen
Sorunome briefly mentioned afterwards that there is no 0.19.0 due to some accidental messed up tagging, and that it was easiest to just call the new version 0.19.1.
Released 0.1.0 (and 0.1.1) this week with read-only session backup enabled 🎉 Also doing more work to make Hydrogen work on IE11 on Windows 7 (it does already for Windows 10), Safari and other browsers where you get TransactionInactiveError during login, hope to release that soon.
I need to give Hydrogren a shot myself, the quick speeds and low RAM usage
are really attractive.
This week, room settings have been updated with a new intermediate screen. The codebase saw the introduction of an AppCoordinator (in swift) which will help us to have a better control on navigation within the app AND to use swift from end to end.
Polyjuice Client v0.3.0 has been released. This release includes many breaking changes. ("Breaking" in the sense of API changes, rather than the sync process suddenly failing to work, which was already featured in a previous release.) This release also includes many changes, such as the client managing more bookkeeping, detecting if it got logged out, and supporting more Matrix features. See the release notes for more information.
I present you a new project I've been working on for some time. It's a bot that allows you to use the admin API through matrix, by typing commands to the bot. The inspiration comes from the OperServ-like bots that allow IRC operators to administrate an IRC server.
The bot exposes some of the available admin APIs and aims to provide some more high level commands by combining different APIs. There is currently one "high level command", !room garbage-collect, which allow you to purge from your HS all rooms without local users.
The project is written in crystal and is my first project in this language. It should be stable in normal conditions, but don't hesitate to fill issues. A Docker image is provided for more convenience.
benpa wanted a bot that replies with a songwhip.com link whenever someone sends a music link (youtube, spotify, apple music, etc), so I wrote a small maubot plugin to do that: https://github.com/maubot/songwhip
It's available at @songwhip:maunium.net
I'm also desperately in need of this for the 10 open.spotify.com links that get thrown at me every week. Thanks Tulir!
It supports E2EE and can be easily extended with Python plugins. Can be used e.g. for GitLab notifications, automated user invites, room creation, and of course can be programmed to react to any message posted in a room.
Soru made a new thing, matrix-gotify. It is a gotify plugin to receive matrix notifications. This means, you can now receive matrix push notifications on your android phone self-hosted without the need of google services! That is why putting the full event in the push notification is actually not a privacy leak in this case.
This plugin could also be used to receive push notifications on any other kind of device that gotify supports.
Please note that this is independent of any matrix client - you don't even need to run one to be able to use this!
I asked whether an OpenPush-like solution be
built on top of this , and Sorunome responded that someone had already
started working on just that! https://github.com/gotify/android/pull/115
This would allow other matrix clients on your phone to get their push
notifications through your gotify client, instead of needing to run a process
each. Great for battery life without proprietary Google blobs!
Homeservers on-the-go
js got Synapse running in a car on a German highway:
the setup is a cigarette lighter to 2x 230V converter, one being used to power the RockPro64, the other being used to power my notebook. My notebook is connected to the hotspot from my phone, while also being connected to a USB ethernet, the other end of which is plugged into the RockPro64.
The notebook then acts as a gateway, as well as SSHing to a tiny VPS with -R, to get a public port, and forwarding that traffic to the RockPro64.
Maybe one day we'll all have an embedded Synapse homeserver in our cars. P2P E2EE
car comms anyone?
I have been through the perils of setting up a TURN server and having VoIP continue to fail, whilst spending hours scratching my head and staring at Wireshark without getting anywhere. When I was given free reign over project choice last year during my internship, I chose to start a tool that tests your homeserver's VoIP configuration, hoping it would be useful to both me and the community at large.
It saw some progress but I never managed to iron out some of the 'last few things' or put a pretty front on it — until about 2 weeks ago, when I got some more time to do it.
There are known issues — such as the scores being very arbitrary, wrong and misleading; it crashes Chromium every time (on my machine) and it completely misbehaves in Brave Browser (on my machine). It may also not be the prettiest (but hopefully it is at least somewhat inoffensive). I hope to work on these annoying issues soon.
I have deployed a test instance at https://test.voip.librepush.net — it can be tried in a WebRTC-supporting browser (probably Firefox if you want half a chance). Please don't take it to heart if you get a Fail or Poor score — it's probably not your fault. :)
Oliver was interning with us at Element this Summer. Fixing up and releasing
this VoIP tester was part of it, but he's still working on it in his spare
time even though his internship has finished :)
Through this I found out that I forgot to turn on my turnserver on my
homeserver again. Thanks Oliver!
Dept of Guides 🧭
German-Language Guide for Getting Start with Matrix
Guides like these are the essential entrypoints to a project for a lot of users. The more, in different languages, the merrier!
Dept of Ping 🏓
Here we reveal, rank, and applaud the homeservers with the lowest ping, as measured by pingbot, a maubot that you can host on your own server. Join #ping:maunium.net to experience the fun live, and to find out how to add YOUR server to the game.
I changed the formatting of the plot a bit to make it more readable. Note that it is now using a log scale which allows us to see more data at the same time.
Now that we have multiple somewhat federating Matrix homeserver implementations, I decided to make a ping room where all the echo bots are hosted on second-gen homeservers: #ping-no-synapse:maunium.net. Synapse users are still allowed to join and !ping, but all the pongs will come from non-Synapse servers.
Based on observations in that room so far, the new server implementations don't like eachother very much.
