Synapse 1.25.0 is now available! With this release, we are deprecating Python 3.5 and PostgreSQL 9.5 and will cease producing binary packages for Debian 9 (Stretch) and Ubuntu 16.04 (Xenial) after a transition period which lasts through March 2021. See the changelog for further details.
We are also deprecating the Purge Room and Shutdown Room Admin APIs and will remove them in a future release. Please update your code to use the Delete Room Admin API instead.
Synapse 1.25.0 brings over a month's worth of improvements, including:
The ability for users to pick their own username when using Single Sign-On, right from within Synapse.
Support for async Python methods in custom spam checker modules.
The spec core team has continued trying out the new spec (preview at: https://adoring-einstein-5ea514.netlify.app/). We've also finished applying design updates and implemented a fancy scrolling table of contents.
We have an outline for how to switch over to the new platform: https://github.com/matrix-org/matrix-doc/issues/2906 and have started work on that this week.
Welcome back, TWiM readers! It's a new year, and the Synapse team is excited to get back to our regularly scheduled releases! Three main things this week:
We published 1.25.0rc1! We'll have full release notes next week, but highlights include:
Deprecated Python 3.5 and Postgres 9.5 per #8782; more details to come with the formal release announcement.
People can pick their own username when using Single Sign-On, right from within Synapse itself.
Spam-checker modules can now use async Python methods.
Matrix is hosting FOSDEM! Which means that most of the Synapse team is going to be focused on security, stability, and performance until February to ensure that our virtual Université Libre de Bruxelles is as reliable and welcoming the real thing.
Speaking of security, we have some big (but good!) news to announce next week. Watch this space... 🕵️🇪🇺💶
Lastly, one of our goals for this year is to maintain a biweekly cadence of release candidates, so we should have a more consistent pace. At the same time, we realize that keeping up with biweekly releases of server-side software can be a bit of a chore, so we're also discussing ways that we could provide longer support for some of our releases. That's a project for much later this year, but consider it a preview of things to come.
If you have any feedback, please feel free to join us in #synapse:matrix.org!
NeoChat gained a few new features this week. The timeline displays stickers now, and edited messages don't get duplicated anymore. NeoChat also now lets you edit your messages. Additionally, Noah improved the support for attachments in the UI, more image formats are detected (and can then be edited in the built-in image editor), and mime type icons get added to non-image attachments. Tobias continues to work on the registration flow and SSO support.
You can meet Carl and Tobias from the NeoChat project by watching Matrix Live. \o/
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.
SchildiChat is a fork of Element, which focuses on UI changes such as message bubbles and a unified chat list for both direct messages and groups, which is a more familiar approach to users of other popular instant messengers.
During the last couple of weeks, SchildiChat-Android development focused mainly on staying up-to-date with the upstream Element codebase (URL previews took some time to make them fit nicely into the bubble layouts), and doing some smaller design improvements (like wider message bubbles for some scenarios, and an intelligent message timestamp placement at the bottom of the bubble, depending on the available space).
Furthermore, we now also have experimental support for MSC2867, which allows you to mark rooms as unread. Note that for now, this feature needs to be enabled in the labs settings, since the MSC is still unstable and not supported by many clients, which means other clients might ignore whether the user has manually marked a chat as unread and thus display it as read anyway.
Code on GitHub: https://github.com/SchildiChat/SchildiChat-android
Some updates below from the team. Not all teams are back from their Christmas breaks yet, and those who are may be a little busy with FOSDEM-specific projects, but we have some updates:
We’re making more progress on the client implementations for Spaces on the web on Android. On Web, recent progress includes implementing notification badges, and on Android we’re progressing from SDK work to initial UI implementations.
Support for Social Login on iOS is in review after resolving some issues around VoiceOver, which is the last Element client to implement support ahead of Synapse landing support for social login in the near future.
Lots of things merged to web: dial pad, call forward, dtmf pad, although most won’t show up in normal use (yet). Other progress on web on hold for fosdem work. Dial pad & phone number lookup support incoming on iOS, and phone number lookup on its way on Android.
We progressed on several things this week. They are not yet merged but almost. They will be part of the next release we will ship next week: social login, app deadlock fix, encrypted message sending speed improvement, xcodegen usage, sending bug reports in background.
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.
I found some time to actually host the docs our library currently has. It is still severely lacking, but it may be interesting to some people like people contributing to Nheko. I'm going to write some higher level docs over the next few weeks, so that people can actually see how to use the library and have some inline examples and more extensive explanations. But for now you can find the barebones descriptions we always had in the source code here: http://nheko-reborn.pages.nheko.im/mtxclient/index.html
Providing docs always gets a big thumbs-up from me!
[email protected] has been released! This version contains early support for Identity Servers and Spaces (MSC1772), as well as easier functions for sending HTML messages and a bunch of other quality of life improvements. Feedback and bugs in #matrix-bot-sdk:t2bot.io.
matrix-spring-boot-sdk is my first attempt to write bots and appservices really fast, then matrix-sms-bridge using this sdk and now migrating the low-level stuff from matrix-spring-boot-sdk to trixnity, so it can be used independently from spring boot 🙂 My plan is to use trixnity for a an open source web client, that can do "Videosprechstunde" in Germany (I don't know the english word for it, maybe video doctor's consultation?).
I recently started a new freelance project and got them to use Matrix as our main communication channel. Since they chose GitHub as our source code platform I got into writing continuous integrations and delivery scripts. But one thing was missing: notifications in our Matrix room. I looked into the GitHub Action Marketplace and found 2 actions that could do that, so that was nice ... but they could not send e2e encrypted messages. Therefore I took up my old issue on how to make e2e encryption work with the js-sdk (https://github.com/matrix-org/matrix-js-sdk/issues/731) with some new found energy and finally solved it. The result is this GitHub action:
https://github.com/select/matrix-message-e2e
While it's almost a full success story there is still one issue to solve: While the action successfully sends e2e encrypted messages the job is marked as failed. My guess it that while sending the messages the matrix client outputs on stderr due to some encryption errors (unknown device keys, ...)
Want to play the guessing game Battleship via Matrix? I'm building one to be ready for FOSDEM. Follow my progress, bring in ideas and play development versions:
I asked: "what's the best tool for dumping history from rooms (including e2e rooms)?", and Florian shared this great tool I don't think I'd seen before:
matrix-archive is the best currently-maintained tool I know of
A really useful project that generates "a YAML log of all room messages, including media".
Based on the original chart by hrjet, here's an easy-to-share comparison chart in image form, that compares a number of alternatives (Element/Matrix, Signal, Telegram) for people looking for an alternative to WhatsApp
Should be very useful for incoming "What do I use instead of WhatsApp?"-type conversations!
Videosprechstunde is quite hot right now, and the technical requirements in terms of security are already handled with matrix.
It is regulated by the german government and is only working for centralised services right now. So there is no way to get it certified with matrix. It might be possible in future (fingers crossed) and then we (Famedly) are also ready to provide it :)
(Government is slightly wrong, it is more the KBV, but the Government also plans to regulate it starting in two years)
Videosprechstunde refers to having a video conference with your doctor, rather than going in-person.
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.
Imagine you could physically step into your favourite FOSS projects’ chatrooms, mailing lists or forums and talk in person to other community members, contributors or committers? Imagine you could see project leads show off their latest work in front of a packed audience, and then chat and brainstorm with them afterwards (and maybe grab a beer)? Imagine, as a developer, you could suddenly meet a random subset of your users, to hear and understand their joys and woes in person?
This is FOSDEM, Europe’s largest Free and Open Source conference, where every year thousands of people (last year, ~8,500) take over the Solbosch campus of the Université Libre de Bruxelles in Belgium for a weekend and turn it into both a cathedral and bazaar for FOSS, with over 800+ talks organised over 50+ tracks, hundreds of exhibitor stands, and the whole campus generally exploding into a physical manifestation of the Internet. The event is completely non-commercial and volunteer run, and is a truly unique and powerful (if slightly overwhelming!) experience to attend. Ever since we began Matrix in 2014, FOSDEM has been thefocalpointofouryear as we’ve rushed to demonstrate our latest work and catch up with the wider community and sync with other projects.
This year, things are of course different. Thankfully FOSDEM 2020 snuck in a few weeks before the COVID-19 pandemic went viral, but for FOSDEM 2021 on Feb 6/7th the conference will inevitably happen online. When this was announced a few months back, we reached out to FOSDEM to see if we could help: we’d just had a lot of fun helping HOPE go online, and meanwhile a lot of the work that’s gone into Matrix and Element in 2020 has been around large-scale community collaboration due to COVID - particularly thanks to all the development driven by Element’s German Education work. Meanwhile, we obviously love FOSDEM and want it to succeed as much as possible online - and we want to attempt to solve the impossible paradox of faithfully capturing the atmosphere and community of an event which is “online communities, but in person!”... but online.
And so, over the last few weeks we’ve been hard at work with the FOSDEM team to figure out how to make this happen, and we wanted to give an update on how things are shaping up (and to hopefully reassure folks that things are on track, and that devrooms don’t need to make their own plans!).
Firstly, FOSDEM will have its own dedicated Matrix server at fosdem.org (hosted by EMS along with a tonne of Jitsi’s) acting as the social backbone for the event. Matrix is particularly well suited for this, because:
We’re an open standard comms protocol with an open network run under a non-profit foundation with loads of open source implementations (including the reference ones): folks can jump on board and participate via their own servers, clients, bridges, bots etc.
We provide official bridges through to IRC and XMPP (and most other chat systems), giving as much openness and choice as possible - if folks want to participate via Freenode and XMPP they can!
We’re built with large virtual communities in mind (e.g. Mozilla, KDE, Matrix itself) - for instance, we’ve worked a lot on moderation recently.
We’ve spent a lot of time improving widgets recently: these give the ability to embed arbitrary webapps into chatrooms - letting you add livestreams, video conferences, schedules, Q&A dashboards etc, augmenting a plain old chatroom into a much richer virtual experience that can hopefully capture the semantics and requirements of an event like FOSDEM.
We’re currently in the middle of setting up the server with a dedicated Element as the default client, but what we’re aiming for is:
Attendees can lurk as read-only guests in devrooms without needing to set up accounts (or they can of course use their existing Matrix/IRC/XMPP accounts)
Every devroom and track will have its own chatroom, where the audience can hang out and view the livestream of that particular devroom (using the normal FOSDEM video livestream system). There’ll also be a ‘backstage’ room per track for coordination between the devroom organisers and the speakers.
The talks themselves will be prerecorded to minimise risk of disaster, but each talk will have a question & answer session at the end which will be a live Jitsi broadcast from the speaker and a host who will relay questions from the devroom.
Each talk will have a dedicated room too, where after the official talk slot the audience can pop in and chat to the speaker more informally if they’re available (by text and/or by moderated jitsi). During the talk, this room will act as the ‘stage’ for the speaker & host to watch the livestream and conduct the question & answer session.
Every stand will also have its own chatroom and optional jitsi+livestream, as will BOFs or other adhoc events, so folks can get involved both by chat and video, to get as close to the real event as possible (although it’s unlikely we’ll capture the unique atmospheric conditions of K building, which may or may not be a bug ;)
There’ll also be a set of official support, social etc rooms - and of course folks can always create their own! Unfortunately folks will have to bring their own beer though :(
All of this will be orchestrated by a Matrix bot (which is rapidly taking shape over at https://github.com/matrix-org/conference-bot), responsible for orchestrating the hundreds of required rooms, setting up the right widgets and permissions, setting up bridges to IRC & XMPP, and keeping everything in sync with the official live FOSDEM schedule.
N.B. This is aspirational, and is all still subject to change, but that said - so far it’s all coming together pretty well, and hopefully our next update will be opening up the rooms and the server so that folks can get comfortable in advance of the event.
Huge thanks go to the FOSDEM team for trusting us to sort out the social/chat layer of FOSDEM 2021 - we will do everything we can to make it as successful and as inclusive as we possibly can! :)
FOSDEM is only a handful of weeks away, and we have our work cut out to bring this all together in time. There are a few areas where we could really do with some help:
Folks on XMPP often complain that the Bifröst Matrix<->XMPP bridge doesn’t support MAMs - meaning that if XMPP users lose connection, they lose scrollback. We’re not going to have time to fix this ourselves in time, so this would be a great time for XMPP folks who grok xmpp.js to come get involved and help to ensure the best possible XMPP experience! (Similarly on other bifrost shortcomings).
It’d be really nice to be able to render nice schedule widgets for each devroom, and embed the overall schedule in the support rooms etc. The current HTML schedules at https://fosdem.org/2021/schedule/day/saturday/ and (say) https://fosdem.org/2021/schedule/room/vcollab/ don’t exactly fit - if someone could write a thing which renders them at (say) 2:5 aspect ratio so they can fit nicely down the side of a chatroom then that could be awesome!
While we’ll bridge all the official rooms over to Freenode, it’d be even nicer if people could just hop straight into any room on the FOSDEM server (or beyond) via IRC - effectively exposing the whole thing as an IRC network for those who prefer IRC. We have a project to do this: matrix-ircd, but it almost certainly needs more love and polish before it could be used for something as big as this. If you like Rust and know Matrix, please jump in and get involved!
If you just want to follow along or help out, then we’ve created a general room for discussion over at #fosdem-matrix:fosdem.org. It’d be awesome to have as many useful bots & widgets as possible to help things along.
I have a feeling experiencing a revolution in how people perceive messaging. Now, public sector and multiple communities adopting Matrix, one cannot think of a world without Matrix any more.
Kudos to the Element team and to the wonderful Matrix community! ♥️
What a wonderful year has been for matrix, and it looks like next year will be equally as exciting. I'm HYPED.
Honestly, I'm hyped too. Simple statements like "loads of different universities have rolled out Matrix for collaboration" don't quite capture how much work is going on, and how much excitement there is to get the growth in the network we're soon to see.
For the first time (since recording the homeserver stats from Feb 2019) a non-synapse homeserver is now in the top 15 deployed homeserver versions: Welcome Dendrite 0.3.4: https://graph.settgast.org/d/z1nplqXik/matrix?orgId=1
How exciting is that! If you haven't already, do check out some of the history on these charts - big thanks to Chris for making this available.
Created a new Ansible role to easily install a Dendrite server. Currently only tested on Ubuntu 20.04 with Ansible 2.9. Uses Docker to maintain a monolithic Dendrite. Requires but does not include PostgreSQL. Designed to easily be used with Traefik as reverse proxy.
Not to be confused with matrix-puppet-groupme, mx-puppet-groupme is a fancy new GroupMe bridge with support for as many features as the web client would let me get my hands on. Please try it out, and let me know on GitLab or Matrix if you have any issues or suggestions! 💜
The KDE Community is excited to announce the first release of NeoChat, a Matrix Client based on Spectral and libQuotient. With the power of Qt and KDE Frameworks, NeoChat currently runs on mobile and desktop Linux devices, Android and Windows. You can read more about NeoChat and how to get it at https://carlschwan.eu/2020/12/23/announcing-neochat-1.0-the-kde-matrix-client/
Congrats on the 1.0! I think we'll hear much more from the team next year. 🎉
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
We finally fixed the Windows build, so there are nightlies on Windows again! Also lorendb finished his profile work, which means that if you were using custom profiles before on one of the nightlies, you may need to login again, but the whole code is a lot cleaner now.
Version 0.6.3 is out, another bugfix release on the stable branch. Nothing too significant, but .well-known-unaware homeservers should be treated better, and Matrix identifiers with special characters (ahem, slashes) can now be turned to valid URIs (matrix.to or proper Matrix URIs). Also, room tags starting with a . are no more considered valid, you'll get u. prepended to them.
Existing installations will get automatically migrated from SQLite/nedb to Postgres the next time you run the playbook.
Not only does this bring better performance and compatibility, but also, being able to reuse the same Postgres database for services other than Synapse paves the way for us to introduce other Postgres-only services such as Dendrite, the mautrix-signal bridge (existing pull request), etc.
Common accounts for support are tricky to handle due to needing the people using those accounts to keep separate clients open to use the common account. For this at Elokapina we created Middleman, which acts as a proxy between an account and a room.
It's a bit basic but works pretty well for pure text messages. Any messages in rooms where the bot is are relayed to the management room and any replies to those messages (prefixed with !reply) in the management room are relayed back. Optionally senders can be anonymised to enable a feedback bot.
Coming up is more configuration on for example ignoring non-mentions in rooms with lots of members and hopefully support for images and reactions in the not too long future.
Find it here: https://github.com/elokapina/middleman (built with nio-template).
Threema published the source code for their apps this week: https://threema.ch/en/open-source
While that is not strictly Matrix related, it is great to see other E2EE enabled chat systems publishing the source code for their clients. It's the only way to verify their encryption actually works and is secure.
This move was announced a while ago, but I think that it actually happened now deserves a small shoutout! 🎉
Quite right! Though Matthew, thought the news needed to be put into proper context:
it’s almost like they’re scrabbling to keep up with matrix ;)
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.
Over the years it’s become a tradition to write an end-of-year wrap-up on Christmas Eve, reviewing all the things the core Matrix team has been up over the year, and looking forwards to the next (e.g. here’s last year’s edition). These days there’s so much going on in Matrix it’s impossible to cover it all (and besides, we now have This Week In Matrix and better blogging in general to cover events as they happen). So here’s a quick overview of the highlights:
Looking back at our plans for 2020 in last year’s wrap-up, amazingly it seems we pretty much achieved what we set out to do. Going through the bulletpoints in order:
We have a dedicated team making major improvements to First-Time User Experience in Element (as of the last few months; hopefully you’ve been noticing the improvements!)
MLS experiments are in full swing - we got the first MLS messages passing over Matrix a few days ago, and Decentralised MLS work is back on the menu after an initial sprint in May.
There’s been a valiant mission to improve Bridge UX in the form of MSC2346 and its implementations in Element Web, although this has ended up failing to get to the top of the todo list (sorry Half-Shot! :/)
Spec progress has improved somewhat, and we are very excited to have welcomed Will Bamberg (formerly MDN) to support the spec from a professional tech writer perspective, with the all-new engine landing any day now! We’re still experimenting with ways to ensure the spec gets enough time allocated to keep up with the backlog, however - particularly community contributions.
...and in terms of Abuse/Reputation - we properly kicked off our anti-abuse work and launched a first PoC implementation in the depths of Cerulean last week.
Perhaps more interesting is the stuff we didn’t predict (or at least didn’t want to pre-announce ;) for 2020:
Riot, Modular and New Vector got unified at last behind a single name: Element; hopefully the shock has worn off by now :)
Mozilla joined Matrix in force, turning off Moznet IRC in favour of going full Matrix.
Automattic launched itself into the Matrix ecosystem with an investment in Element, and since then we’ve been working on getting Matrix better integrated and available to them (although all of Element’s Matrix-for-governments activity has ended up delaying this a bit). If you want to work for Automattic on integrating Matrix, they’re hiring!
We previewed Cerulean as a super-exciting proof-of-concept client, demonstrating how social media could work on Matrix, with native threading, profiles-as-rooms, decentralised reputation, and (shortly) peeking-over-federation.
We completely rewrote matrix.to and relaunched it as a much more capable and friendly permalink redirection service; a precursor to finally getting matrix:// URLs everywhere!
We certainly didn’t predict that the “how to install Synapse” video tutorial published at the beginning of the COVID-19 pandemic would end up with 25.5K views (and counting…)
Then, there’s whole new waves of exciting stuff going on. The most obvious has to be the amount of Government uptake we’ve seen with Matrix this year, following on from France embracing Matrix across the public sector last year. Firstly the German armed forces announced their transition to Matrix, and then the German states of Schleswig-Holstein and Hamburg announced a mammoth 500K user Matrix deployment for education and public administration. Meanwhile, North Rhine Westphalia (the biggest state in Germany) launched their own Matrix-powered messager for education; loads of different universities have rolled out Matrix for collaboration - and we hear Famedly is making good progress with Matrix-powered healthcare messaging solutions. Finally, outside of Germany, we’re seeing the first official deployments in the UK government and US federal government - we’ll share details where possible (but sometimes big deployments of encrypted communication systems want to remain discreet). It’s incredibly exciting to see Matrix spreading across the public sector and education, and we’re hoping this will follow a similar pattern to how the Internet, email or indeed the Web first developed: a mix of high profile public sector deployments, complemented by a passionate grass-roots technical community, eventually spreading to span the rest of society :).
Another exciting thing which emerged this year is the amazing academic work that Karlsruhe Institute of Technology’s Decentralized Systems and Network Services Research Group has been conducting on Matrix. This really came on the radar back in June when their Matrix Decomposition: Analysis of an Access Control Approach on Transaction-based DAGs without Finality paper was published - a truly fascinating analysis of how state resolution works in Matrix, and how we manage to preserve access control within rooms without using blockchain-style ‘sealed blocks’ (and has helped fix a few nasty bugs!). I’m not sure any of us realised that Matrix’s state resolution counts as a new field of research, but it’s been great to follow along with their independent work. Most recently, and even more excitingly, they’re circulating a preview of their Analysis of the Matrix Event Graph Replicated Data Type paper - a deep analysis of the properties of Matrix DAGs themselves. We highly recommend reading the papers (what better way to spend the holiday break!). To give a taste, the final paragraph of the paper concludes:
2020 has also seen the arrival and maturation of a whole new generation of Matrix clients - Hydrogen is really impressive as an experimental next-generation Web (and Mobile Web) client; an account with 3000 rooms that uses 1.4GB of RAM on Element Web uses 14MB of RAM on Hydrogen and launches instantly, complete with excellent E2EE implementation. It even works on MSIE! The whole app, including dependencies, is about 70KB of code (200KB including Olm). Meanwhile, matrix-rust-sdk is coming along well, providing a general purpose native library for writing excellent native Matrix clients. Fractal merged initial matrix-rust-sdk a few weeks ago, and we’ll be experimenting with switching to it in Element iOS and Element Android (for its e2ee) in the coming year. It’s not inconceivable to think of a world where matrix-rust-sdk ends up being the no-brainer official SDK for native apps, and Hydrogen’s SDK becomes the no-brainer official SDK for JS apps.
Meanwhile, in the community, there’s been so much activity it’s untrue. But on the subject of maturing apps, it’s been incredibly exciting to see NeoChat emerge as an official KDE Matrix client (built on libQuotient and Kirigami, forked from Spectral), FluffyChat going from strength to strength; Nheko continuing to mature impressively; Mirage appearing out of nowhere as a fully featured desktop client; Fractal merging matrix-rust-sdk etc. On the serverside, Conduit was the big community story of the year - with an incredibly fast Rust + Sled server appearing out of the blue, with viable federation coming up on the horizon. The best bet for an overview of all things community is to checkout the TWIM backlogs however - there’s simply way too much stuff to mention it all here.
Obviously, no 2020 wrap-up post would be complete without acknowledging the COVID-19 pandemic - which increased focus on Matrix and other remote collaboration technology more than anyone could have predicted (especially given all the privacy missteps from Zoom, Teams and others). One of the highlights of the year was seeing the HOPE (Hackers On Planet Earth) conference shift their entire proceedings over to Matrix - turning the conference into a 10 day television station of premium hacking content, with Matrix successfully providing the social glue to preserve a sense of community despite going virtual. Similarly, we’re incredibly excited that FOSDEM 2021 is highly likely to run primarily via Matrix (with bridges to IRC and XMPP, of course) - our work is going to be cut out for us in January to ensure the amazing atmosphere of FOSDEM is preserved online for the >8,500 participants and ~800 talks. And if any other event organisers are reading this - please do reach out if you’re interested in going online via Matrix: we want Matrix to be the best possible ecosystem for online communities, including virtual events, and we’ll be happy to help :)
Talking of FOSDEM, a really fun bit of work which landed in Element this year was to (finally!) polish Widgets: the ability to embed arbitrary webapps into Matrix chatrooms. This includes being able to embed widgets in the RightPanel on Element Web, the LeftPanel too, add as many as you like to a room, resize them(!), and generally build much more sophisticated dashboards of additional content. Modal and fullscreen widgets are coming too, as are ways to simplify and unify access control. It turns out that these have arrived in the nick of time for events like FOSDEM, where we’re expecting to very heavily use widgets to embed video streams, video conferences, schedules, and generally automate the workflow of the conference via adding in web UIs as widgets wherever necessary. The work for this has been driven by the various German education deployments, where the same tricks are invaluable for automating online learning experiences. We originally wrote Widgets back in 2017 as a proof-of-concept to try to illustrate how chatrooms could be used to host proper custom UIs, and it's fantastic to see that dream finally come of age.
Finally, it’s been really exciting to see major progress in recent months on what’s essentially a whole new evolution of Matrix. Two years ago, a quiet patch during the Christmas holidays gave birth to a whole bunch of wild science fiction Matrix Spec Changes: MSC1772: Spaces (groups as rooms), MSC1769: Profiles as rooms, MSC1767: Extensible events, MSC1776: Peeking over /sync, MSC1777: Peeking over federation, etc. This was in part trying to ensure that we had something to look forward to when we emerged from the tunnel of launching Matrix 1.0, and in part trying to draw a coherent high-level sketch of what the next big wave of Matrix features could look like. Inevitably the MSCs got stuck in limbo for ages while we exited beta, launched Matrix 1.0, turned on E2EE by default etc - but in the latter half of this year they’ve hit the top of the todo list and it’s been incredibly exciting to see entirely new features landing once again. Implementation for Spaces is in in full swing and looking great; Profiles-as-rooms are effectively being trialled in Cerulean; Peeking over /sync has landed in Dendrite and peeking over federation is in PR (and unlocks all sorts of desirable features for using rooms more generically than we have today, including Spaces). Only Extensible events remains in limbo for now (we have enough to handle getting the others landed!)
Of these, Spaces has turned out to be exciting in wholly unexpected ways. While prototyping the UX for how best to navigate hierarchies of spaces, we had a genuine epiphany: the ability for anyone to define and share arbitrary hierarchies of rooms makes Matrix effectively a global decentralised hierarchical file system (where the ‘files’ are streams of realtime data, but can obviously store static content too). The decentralised access controls that KIT DSN wrote about could literally be file-system style access controls; enforcing access on a global decentralised hierarchy. We obviously have shared hierarchical filesystems today thanks to Dropbox and Google Drive, but these of course are centralised and effectively only store files - whereas Spaces could potentially scale to the whole web. In fact, you could even think of Spaces as flipping Matrix entirely on its head: the most defining building block going forwards could be the Spaces themselves rather than the rooms and events - just as directories are intrinsic to how you navigate a conventional filesystem. How has Matrix got this far without the concept of folders/directories?!
Right now these thoughts are just overexcited science fiction, but the potential really is mindblowing. It could give us a global read/write web for organising any arbitrary realtime data - with the social controls via ACLs to delegate and crowdsource curation of hierarchies however folks choose. The Matrix.org Foundation could seed a ‘root’ hierarchy, go curate all the rooms we know about into some Linnean-style taxonomy, delegate curation of the various subspaces to moderators from the community, and hey presto we’ve reinvented USENET… but with modern semantics, and without the rigid governance models. Hell, we could just mount (i.e. bridge) USENET straight into it. And any other hierarchical namespace of conversations you can think of - Google Groups, Stackoverflow, Discourse, IMAP trees…
Of course, the initial Spaces implementation is going to be focused of on letting communities publish their existing rooms, and users organise their own rooms, rather than managing an infinite ever-expanding global space hierarchy - but given we’ve been designing Spaces to support government (and inter-government) scales of Spaces, it’s not inconceivable to think we could use it to navigate gigantic public shared Spaces in the longer term.
Anyway, enough Space scifi - what’s coming up in 2021?
Social Login - we’re going to be making Single Sign On (SSO) a proper first-class citizen in Matrix (and Synapse and Element) in the coming weeks, and enabling it on the matrix.org homeserver, so users can do single-click logins via Github/Gitlab/Google and other SSO providers. Obviously this means your Matrix identity will be beholden to your identity provider (IdP), but this may well be preferable for many users who just want a single-click way to enter Matrix and don’t care about being tied to a given IdP.
VoIP - we have a lot of work in flight at the moment to make 1:1 VoIP super robust. Some of it has already landed in Element, but the rest will land in the coming weeks - and then we’re hoping to revisit Matrix-native group voice/video.
Voice messaging - we’re hoping to finally add voice messaging to Element (and Matrix)
Location sharing - ...and this too.
**P2P **- Lots of P2P work on the horizon, now Dendrite is increasingly stable. First of all we need to iterate more on Pinecone, our pre-alpha next-generation P2P overlay network - and then sort out account portability, and privacy-preserving store-and-forward. We’re hoping to see the live P2P Matrix network turn on this year, however, and ideally see homeservers (probably Dendrite) multihoming by default on both today’s Matrix as well as the P2P network, acting as gateways between the two.
Threads - Cerulean is excellent proof for how threading could work in Matrix; we just need to get it implemented in Element!
Peeking - Peeking is going to become so much more important for participating in non-chat rooms, such as Spaces, Profiles, Reputation feeds, etc. We’ll finish it in Dendrite, and then implement it in Synapse too.
**Decentralised Reputation **- Cerulean has the first implementation of decentralised reputation for experimentation purposes, and we’ll be working solidly on it over the coming year to empower users to counter abuse by applying their own subjective reputation feeds to their content.
**Incremental Signup **- Once upon a time, Element (Riot) had the ability to gradually sign-up without the user even really realising they’d signed up. We want to bring it back - perhaps this will be the year?
DMLS - with the first MLS messages flowing over Matrix, we want to at least provide MLS as an option alongside Megolm for encryption. It should be radically more performant in larger rooms (logarithmic rather than linear complexity), but lacks deniability (the assurance that you cannot prove a user said something in retrospect, in order to blackmail them or similar), and is still unproven technology. We’ll aim to prove it in 2021.
E2EE improvements - We improved E2EE immeasurably in 2020; turning it on by default, adding cross-signing, QR code verification etc. But usability and reliability can still be improved. We’ll be looking at further simplifying the UX, and potentially combining together your login password and recovery/security passphrase so you only have one password to remember going forwards.
Hydrogen - We’ll keep polishing Hydrogen, bringing it towards feature parity with Element, ensure its SDK is available for other clients, and start seeing how we can use it in Element itself. For instance, the Spaces-aware RoomList in Element may well end up stealing alien technology from Hydrogen.
matrix-rust-sdk - Similarly, we’ll keep polishing matrix-rust-sdk; stealing inspiration from Hydrogen’s state model, and start migrating bits of the native mobile Element apps to use it.
The Spec - get Will’s new spec website live, and get improving all the surrounding material too.
I’m sure I’m missing lots here, but these are the ones which pop immediately to mind. You can also check Element's public roadmap, which covers all the core Matrix work donated by Element (as well as everything else Element is getting up to).
As always, huge huge thanks goes to the whole Matrix community for flying Matrix and keeping the dream alive and growing faster than ever. It’s been a rough year, and we hope that you’ve survived it intact (and you have our sincere sympathies if you haven’t). Let’s hope that 2021 will be a massive improvement, and that the whole Matrix ecosystem will continue to prosper in the new year.
We have a bit of an unexpected early Christmas present for you today…
Alongside all the normal business-as-usual Matrix stuff, we’ve found some time to do a mad science experiment over the last few weeks - to test the question: “Is it possible to build a serious Twitter-style decentralised microblogging app using Matrix?”
It turns out the answer is a firm “yes” - and as a result we’d like to present a very early sneak preview of Cerulean: a highly experimental new microblogging app for Matrix, complete with first-class support for arbitrarily nested threading, with both Twitter-style (“vertical”) and HN/Reddit-style (“horizontal”) layout… and mobile web support!
This is to show just how simple a fairly sophisticated Matrix client can be...
...and so the code can be easily understood by folks unfamiliar with Matrix...
...and so we can iterate fast while figuring out threading...
...and because none of the SDKs support threading yet :D
It relies on MSC2836: Threading - our highly experimental Matrix Spec Change to extend relationships (as used by reaction & edit aggregations) to support free-form arbitrary depth threading.
As such, it only works on Dendrite, as that’s where we’ve been experimenting with implementing MSC2836. (We’re now running an official public Dendrite server instance at dendrite.matrix.org though, which makes it easy to test - and our test Cerulean instance https://cerulean.matrix.org points at it by default).
This is **very much a proof of concept. **We’re releasing it today as a sneak preview so that intrepid Matrix experimenters can play with it, and to open up the project for contributions! (PRs welcome - it should be dead easy to hack on!). Also, we give no guarantees about data durability: both Cerulean and dendrite.matrix.org are highly experimental; do not trust them yet with important data; we reserve the right to delete it all while we iterate on the design.
Obviously, there’s a huge amount of stuff needed for parity with a proper Twitter-style system:
Configurable follows. Currently the act of viewing someone’s timeline automatically follows them. This is because Dendrite doesn’t peek over federation yet (but it’s close), so you have to join a room to view its contents - and the act of viewing someone’s timeline room is how you follow them in Cerulean.
Likes (i.e. plain old Matrix reactions, although we might need to finally sort out federating them as aggregations rather than individually, if people use them like they use them on Twitter!)
Retweets (dead easy)
Pagination / infinite scrolling (just need to hook it up)
Protect your posts (dead easy; you just switch your timeline room to invite-only!)
Show (some) replies to messages in the Home view
Show parent and sibling context as well as child context in the Thread view
Mentions (we need to decide how to notify folks when they’re mentioned - perhaps Matrix’s push notifications should be extended to let you subscribe to keywords for public rooms you’re not actually in?)
Notifications (although this is just because Dendrite doesn’t do notifs yet)
Search (again, just needs to be implemented in Dendrite - although how do you search beyond the data in your current homeserver? Folks are used to global search)
Hashtags (it’s just search, basically)
Symlinks (see below)
Figure out how to handle lost unthreaded messages (see below)
Offline support? (if we were using a proper Matrix SDK, we’d hopefully get this for free, but currently Cerulean doesn’t store any state locally at all).
Every message you send using Cerulean goes into two Matrix rooms, dubbed the "timeline" room and the "thread" room. The "timeline" room (with an alias of #@matthew:dendrite.matrix.org or whatever your matrix id is) is a room with all of your posts and no one else's. The "thread" room is a normal Matrix room which represents the message thread itself. Creating a new "Post" will create a new "thread" room. Replying to a post will join the existing "thread" room and send a message into that room. MSC2836 is used to handle threading of messages in the "thread” room - the replies refer to their parent via an m.relationship field in the event.
These semantics play nicely with existing Matrix clients, who will see one room per thread and a flattened chronological view of the thread itself (unless the client natively supports MSC2836, but none do yet apart from Cerulean). However, as Cerulean only navigates threaded messages with an m.reference relationship (eg it only ever uses the new /event_relationships API rather than /messages to pull in history), normal messages sent by Matrix into a thread or timeline room will not yet show up in Cerulean.
In this initial version, Cerulean literally posts the message twice into both rooms - but we’re also experimenting with the idea of adding “symlinks” to Matrix, letting the canonical version of the event be in the timeline room, and then the instance of the event in the thread room be a ‘symlink’ to the one in the timeline. This means that the threading metadata could be structured in the thread room, and let the user do things like turn their timeline private (or vice versa) without impacting the threading metadata. We could also add an API to both post to timeline and symlink into a thread in one fell swoop, rather than manually sending two events. It’d look something like this:
We also experimented with cross-room threading (letting Bob’s timeline messages directly respond to Alice’s timeline messages and vice versa), but it posed some nasty problems - for instance, to find out what cross-room replies a message has, you’d need to store forward references somehow which the replier would need permission to create. Also, if you didn’t have access to view the remote room, the thread would break. So we’ve punted cross-room threading to a later MSC for now.
Needless to say, once we’re happy with how threading works at the protocol level, we’ll be looking at getting it into the UX of Element and mainstream Matrix chat clients too!
Cerulean is very much a test jig for new ideas (e.g. threading, timeline rooms, peeking), and we’re taking the opportunity to also use it as an experiment for our first forays into publishing and subscribing to reputation greylists; giving users the option to filter out content by default they might not want to see… but doing so on their own terms by subscribing to whatever reputation feed they prefer, while clearly visualising the filtering being applied. In other words, this is the first concrete experimental implementation of the work proposed in the second half of Combating Abuse in Matrix without Backdoors. This is super early days, and we haven’t even published a proto-MSC for the event format being used, but if you’re particularly interested in this domain it’s easy enough to figure out - just head over to #nsfw:dendrite.matrix.org (warning: not actually NSFW, yet) and look in /devtools to see what’s going on.
So, there you have it - further evidence that Matrix is not just for Chat, and a hopefully intriguing taste of the shape of things to come! Please check out the demo at https://cerulean.matrix.org or try playing with your own from https://github.com/matrix-org/cerulean, and then head over to #cerulean:matrix.org and let us know what you think! :)
Introducing Cerulean - highly experimental threaded microblogging for Matrix. Read all about it at https://matrix.org/blog/2020/12/18/introducing-cerulean
The last set of community demos were well received, so if you have an idea for a demo, get it ready for 2021-01-15, which will be the next demo session!
The spec core team has been trying out the new spec this week to decide if it's ready to ship. And we've been applying Dean's design updates (currently in a separate branch at https://friendly-yonath-3de225.netlify.app/).
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 made a healthy amount of progress on the MSCs in focus. A few members have also been iterating quite a bit on MSC1772 for Spaces. Look for these MSCs to start landing come the first few weeks of the New Year as implementation work starts to relax a bit. The focus for next week is... Christmas! 🎄
But first week of January will be MSC2844, MSC2366 (ready and done in key verification) and MSC2790 (modal widgets).
If you haven't already seen it, we wrote a Dendrite 2020 Progress Update blog post detailing our year in Dendrite. It also includes an announcement for our new public dendrite.matrix.org homeserver, which is open for registration!
Today we released Dendrite 0.3.4, which is a performance and bug-fix release, including the following changes from the last two weeks:
The stream tokens for /sync have been refactored, giving PDUs, typing notifications, read receipts, invites and send-to-device messages their own respective stream positions, greatly improving the correctness of sync
A new roominfo cache has been added, which results in less database hits in the roomserver
Prometheus metrics have been added for sync requests, destination queues and client API event send perceived latency
Event IDs are no longer recalculated so often in /sync, which reduces CPU usage
Sync requests are now woken up correctly for our own device list updates
The device list stream position is no longer lost, so unnecessary device updates no longer appear in every other sync
A crash on concurrent map read/writes has been fixed in the stream token code
The roomserver input API no longer starts more worker goroutines than needed
The roomserver no longer uses the request context for queued tasks which could lead to send requests failing to be processed
A new index has been added to the sync API current state table, which improves lookup performance significantly
The client API /joined_rooms endpoint no longer incorrectly returns null if there are 0 rooms joined
The roomserver will now query appservices when looking up a local room alias that isn't known
The check on registration for appservice-exclusive namespaces has been fixed
If you are running a Dendrite server, it is highly recommended that you upgrade to the latest version!
Hello again from Synapse land! This is our last TWiM of 2020, but we're hard at work landing our last patches before going on holiday. Expect 1.25.0rc1 in early January with loads of fixes, performance improvements, and a few new features. In particular:
@anoadragon453 has been hard at work implementing knocking, while also chipping away at getting Synapse to pass the complement test suite for Matrix homeservers — Thank you, Andrew
@babolivier resolved a thorny issue with user directory search, where we were mistakenly ignoring English stop words like "be" and "the" when searching for users... so if you were trying to look up your colleague Theresa, you'd start getting results at Th, lose them at The, get them back at Ther, lose them again at There, and so on — Thank you, Brendan
You can look forward to all of this and more next year, but until then, happy holidays from all of us over here at Element and in the broader Synapse community!
Hello everyone! It's been ages since I've talked about a personal project on here. I've been working on the matrix-github bridge, which is an all singing all dancing service to connect you to Github AND Gitlab. (Yes, it's now poorly named).
I've landed the initial bits to make GitLab work, so that you can join issues and MRs as rooms in the UI but there is more work to do to make that solid and more interactive. The thing I am most looking forward to is notifications for GitLab so I can get away from emails.
ALSO, off the back of TravisR's fantastic widget work, I've landed initial support for widgets in admin rooms and soon issue/PR rooms. The idea here being that widgets give you a nicer UI to control the bridge or render details like commits going past or diffs. All the groundwork for authenticating widgets against the bridge and rendering them is done, now it just needs features.
That's the highlights this week. I'm hoping to really tighten the documentation to get more people spun up on it as the notifications features have turned out to be a killer feature for me :)
I've been using this (the bridge, rather than the upcoming widgets) for a couple of months now and find it really really powerful. I'm not in GitHub most of the day, so getting notifs piped direct into Matrix is great!
I added bridging of typing notifications and read receipts from Matrix to Instagram and fixed a bunch of bugs. Only thing that's still missing is presence and Matrix->Instagram non-image files.
This is now almost feature complete! Nice one Tulir.
A few updates to the Gitter bridge itself this week handling Matrix edits outside of the 5 minute edit window on Gitter and fixing up @mentions being mangled by : colons on the Gitter side when someone mentions you from Element. We also strip the redundant Matrix reply quote when it goes into a Gitter threaded conversation because it's already easily viewable in the thread.
We’ve been progressing spaces on Web, focusing on managing spaces, members and rooms. Meanwhile, we’ve also been iterating on designs for all platforms.
Social login
Synapse support for picking a username should be landing in develop today focusing next on supporting multiple identity providers. On iOS, we’ve implemented SSO redirect authentication mechanisms which also should land soon.
VoIP
We’ve been making progress all round on all platforms, with the next web release including improvements to holding & resuming calls and multiple line support!
In celebration of the cross-signing MSC being finally merged, Nheko master now supports cross signing other users and your own devices. 🎉 The UX is currently not final, you have to manually fetch the cross signing keys in the settings, if you don't have them after a verification. You are also not yet prompted to verify new logins and can't bootstrap cross-signing from Nheko, but the functional bits and bobs are there now. We are also still investigating, if prompting for your recovery key/passphrase is less confusing by using just one input field or if we should prompt for them separately. Currently Nheko just asks you to unlook and will accept whatever you input (if it can decrypt the secrets with it). FluffyChat does that and I think it is really nice!
There are also a few smaller features added recently:
Nheko now uses the icon from your theme on the login page
You can react instead of reply with a (very) short text using /react
A few improvements(?) regarding whitespace and code rendering.
Today, we can announce the web/desktop variant of SchildiChat is out of beta!
SchildiChat is a fork of Element, which focuses on UI changes such as message bubbles and a unified chat list for both direct messages and groups, which is a more familiar approach to users of other popular instant messengers.
Since the last announcement on TWIM, we have not only fixed most of the layout bugs caused by the message bubbles, but can also report the following:
Settings for layouts work, so you can also use SchildiChat if you only want the unified overview and no message bubbles
All information about desktop is now on our new website: https://schildi.chat/desktop
The hosted instance is now here: https://app.schildi.chat
For Linux, SchildiChat is now available from AUR, apt repo for debian, flathub and as AppImage
There's a portable Windows version now too
Code on GitHub: https://github.com/SchildiChat/schildichat-desktop
FluffyChat 0.24.0 is released with new features and fixes.
What is new:
A new public room discovery page, where you can find and join public rooms
Experimental bootstrap support for cross-signing and keybackup and something really weird that is named SSSS
Enhanced power level managing for rooms
Minor design changes like a new icon set
Beside of that we have of course a lot of bug fixes and stability improvements. All languages should now also work on iOS.
Also we are looking forward to publish the app in the AppStore for iOS but we will do this under the hood of Famedly. Btw. FluffyChat will soon move to the Famedly GitLab project and we will move the app in the PlayStore to the Famedly account too. This doesn't mean that anything will change there. It is just that Famedly will now handle the legal stuff for us and may offer paid customer support for businesses, which have interest in FluffyChat. But the app will still be available under the same AGPL3 license. This will just make it easier for us to publish the app in the official stores as we don't need to pay so much for the developer accounts.
Numerous new features and fixes arrived this week. Getting closer to production readiness. Famedly also started daily internal testing for the bot to find more issues and fixing them.
It's the most wonderful time of the year! The ⛄️ winter edition of Games Done Quick is almost upon us. This recurring speedrunning event helps raise money for charity each year. As usual, the proceeds of the week long AGDQ are going to the Prevent Cancer Foundation. With some luck we might break last year's $3.13 million record.
To help you keep track of the event I've created GDQBot. Right now you can use it to query for the schedule. Next week should see the code land to add the announcer routine so the bot will announce events as they happen to channels its invited to.
Also a big thank you to tulir for patiently answering my questions as I was trying to find my way around mautrix-go.
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.
One of the goals on the core team is to reduce friction for new users joining Matrix. A challenge we regularly face is all the factors which make Matrix flexible and powerful as an open, secure decentralised protocol also increase the difficulty of getting started.
As one example— to create a healthy, vibrant ecosystem and put power back into the hands of end users, it’s critical multiple clients exist, and that users ultimately have control over which one to use. However, needing to choose a client before getting going is counter-intuitive, and adds cognitive load which proprietary services simply don’t have.
Striking this balance is tricky, and one we’re aiming to improve with the latest version of Matrix.to.
Matrix.to is a simple URL redirection service which lets users share links to rooms, users and communities. It isn’t tied to any client, and for end users it serves as a landing page for many as their first touch to Matrix. And until the matrix:// URI scheme is deployed commonplace (we finally registered it with IANA a few months ago!) it is the only client-agnostic way to link to content in Matrix.
It’s privacy preserving, with no information stored server side, with all calculation done in client-side JavaScript. It started life years ago as a temporary minimum viable hack by Matthew which then hung around untouched for years being… minimally viable. But we’ve recently given it a huge upgrade in usability and functionality at last!
We’ve re-written matrix.to from scratch, giving it a visual upgrade and refocused the experience around:
Helping new users find the best client for them to easily get going. By default, links will prioritise showing clients which are compatible with the platform the link is being viewed from, including mobile platforms.
Optionally, remembering your preferred client for future visits. This also includes deeplinking into native apps for Element Desktop & Element Mobile (and in future, other clients too, of course).
Fetching useful previews. One of our main observations when testing with new users is a lack of confidence trying out a new service without personalised, contextual information on the rooms or people they’re heading to. Matrix.to now displays room metadata like avatars, names and topics directly (fetched via matrix.org by default, asking for permission).
We’ve baked in the ability to specify clients and deployments within links, allowing sharing to give the option of a specific destination to guarantee a predictable experience. For instance, Mozilla might share matrix.to links which recommend using chat.mozilla.org, if you don’t already have a preferred Matrix client configured. We’ve yet to implement this feature in Element, but we’ll be researching and experimenting with different implementations soon and will recommend best practises when we have them.
We plan to evolve matrix.to over time, including eventually evolving it to better support the Matrix URI scheme. As before, you can find the source code on GitHub and please go ahead and submit pull requests to get your Matrix client listed.
It's been a year since Dendrite development picked up again and it's certainly
been a busy one at that! We started off 2020 by sprinting to complete the FOSDEM P2P
demo and, since then, we have continued to develop Dendrite into a more featureful
and stable homeserver.
In October, we moved Dendrite into beta,
and have since released a number of releases. We've also seen quite a lot of interest
from the community, so I'm here today to write about some of the fun things that have
been going on in Dendrite-land.
I'm happy to announce that we've finally deployed our own public Dendrite instance at
dendrite.matrix.org! It's running the latest Dendrite code and is open for
registration, so if you have been looking for an opportunity to play with Dendrite
without hosting your own deployment, here's your chance!
There are still bugs and missing features, but overall the server is quite usable, so
please feel free to register and try it and let us know how you get on.
This is the first deployment that we've built for any kind of scale, so we are cautious
of the fact that there may be performance bottlenecks still. That said, over the last
few weeks, a number of performance-improving changes have been merged, including:
Around 20x performance improvement on the State Resolution v2 algorithm, which is used
in room versions 2 and above
Significantly reducing the amount of time spent recalculating event reference hashes
and event IDs in the roomserver and sync API, reducing CPU usage
Optimised memory usage and reduced database hits in the federation sender, which helps
particularly in large rooms with lots of resident servers
We're optimistic that running this deployment will help us to identify scaling pain
points and to make Dendrite leaner in the long run. Feel free to sign up and give it
a spin! :-)
Since the beginning of the year, we've added a number of new features, including but
not limited to:
Room versions support for all currently specced versions (v1-v6), including support
for State Resolution v2
SQLite storage support in addition to PostgreSQL, largely useful for the P2P demos
Support for database schema upgrades, making updating Dendrite significantly easier
Early end-to-end encryption support, including device list syncing and send-to-device
messages, although with key backup and cross-signing still to come
A number of federation features, including invites, retries and backing off unreachable
homeservers
User-interactive authentication (UIA), which is used in password changes and deleting
devices from your device list
Support for local pagination, backfilling over federation and fetching missing events
Redaction of events both locally and over federation
Entirely new microservices for managing server signing keys, E2E keys, user and device
management
Lots of great contributions from the community - including all of Read Receipts (thanks to S7evinK) and Read Markers (thanks to Lesterpig)!
Of course, Dendrite also needs to be able to fulfill the promise of being a usable
next-generation Matrix homeserver at the same time as being a sci-fi development
platform. We have spent much of the last year working specifically on this. Today,
Dendrite's Sytest compliance sits at:
59% compliance for Client-Server APIs, up from 33% in May 2020
83% compliance for Server-Server APIs, up from 26% in May 2020
As you can see, these are significant leaps in the numbers of tests passing against
Dendrite.
We have been increasingly trying to use Dendrite for the development and testing of
some new Matrix feature proposals. Recently we've seen early support added for
Peeking (MSC2753) and there
is work in progress on Peeking over Federation (MSC2444).
Peeking enables temporarily subscribing to a room for real-time events without joining
the room. This will only be possible with rooms that are world-readable, but it reduces
the overhead of looking into a room significantly as there is no need to update the room
state for each peeking user/device.
In addition to that, we've also been working on Threading (MSC2836)
support, which is the gateway to building some pretty new and interesting Matrix
experiences. Twitter-like or Reddit-like social prototypes like this have traditionally
been difficult to build on top of Matrix as the m.reference relation type from MSC1849
had never really been fleshed out.
Threading adds m.relationship fields for embedding these relationships, and also
specifies an additional /event_relationships API endpoint for finding other events
related to a given event in either direction. This makes it possible to build threads.
Dendrite has also been our primary development platform for P2P Matrix. This year we
have released multiple P2P Matrix demos, including:
p2p.riot.im, which uses libp2p rendezvous and embeds a full
Dendrite homeserver into an in-browser Service Worker
Element iOS P2P, available on TestFlight,
which embeds a full Dendrite homeserver into the Element iOS app, initially using
QUIC over Yggdrasil as a transport for federation
traffic, but with more recent versions using QUIC over the experimental Pinecone protocol
dendrite-demo-libp2p,
a standalone binary which formed the basis of the FOSDEM 2020 P2P demo, using libp2p and
local multicast discovery as a transport for federation traffic
dendrite-demo-yggdrasil,
another standalone binary like above, but using QUIC over Yggdrasil connectivity instead
of libp2p as the transport for federation traffic
Each experiment teaches us more about potential issues that need to be resolved in order
to bring P2P Matrix closer to being reality, and we are continuing to use Dendrite for
this work. We'll be announcing more information in the New Year about our latest efforts
and the Pinecone routing scheme that we are developing.
It's also worth highlighting that all of the other experimental work taking place right
now, including Threading and Peeking, also work over P2P!
We'll be taking a short break for Christmas, but will then be continuing work on
Dendrite in 2021, with the main aims being to add new features, improve spec compliance
further, fix bugs and eventually exit beta. We'll also be continuing further experimental work in the
P2P and Threading areas, as well as supporting the development of new MSCs such as
Portable Identities (MSC2787).
We'd like to say thank you for the community support and interest, and also to send
out a special thanks to our community contributors who have contributed a number of
fixes and features in recent months! We always welcome code contributions via
GitHub if you are an interested developer.
Lots of things to talk about! Firstly I'm very happy to say that spaces are happening, you can keep track of them here: https://github.com/vector-im/element-web/issues/15930.
Next Open Tech Will Save Us, was great this month, and you can also get a great introduction to Matrix Spaces there too.
Then, Marcus Schopen shared his love for Matrix by showing us the Matrix-branded mugs he has had printed:
If you'd like to buy some OFFICIAL Matrix merch (we don't have mugs just yet), then please go to The Matrix Shop! Marcus also added:
New spec platform: we've asked the spec core team to spend some proper time with the new spec so we can decide if it's ready to ship.
You can also file bugs at https://github.com/matrix-org/matrix-doc/labels/spec-redesign
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 continued to be quite busy with implementation during holiday crunch time. There were some constructive ideas for the team to carve out more time for spec work during this week's Spec Core Team retro, which will hopefully lead to an improved cadence this week and into the new year.
As such, the focus remains at MSC2844 (global versioning), MSC2366 (ready and done in key verification), and MSC2790 (modal widgets).
Hello, friends! On Wednesday we released Synapse 1.24.0 and 1.23.1, which include security fixes. Please upgrade! (Also, if you've installed Synapse from source, be sure to pip install 'cryptography>=3.3' in your virtualenv to address the recent OpenSSL CVE).
This is our last full release for the year, as we don't want to do anything that might risk the stability Santa's federated command and control centre at the North Pole, but we're looking forward to lots of new features and improvements in the new year — more details on that next week.
We'd also like to remind you that we're planning on removing support for Python 3.5 early next year (a formal announcement and timeline will accompany the 1.25.0 release), and we'd appreciate and comments or concerns in this GitHub issue.
Strikes me that Santa has a more centralised operation, but who can say?
Just updated my Synapse K8s-optimized image and Chart to 1.24.0, planning on deprecating the image at some point soon though, instead pointing people to upstream - or platform-optimized - images as I should be able to move all the Kubernetes-specific things into the chart itself to make it more compatible.
The image in question started off as a plain docker image, before there were official ones. I've since rebased it onto the official Matrix image with just the modified scripts and volume points.
My plan is to move all the Kubernetes-specific scripts into configmaps (which are a K8s way of storing text files/environment variables/etc), and then build my own launch arguments through the chart to get it to run on any image that has a Python interpreter and the Synapse modules available in the Python search path.
With all that done, it means I won't be a bottleneck in pushing updated image tags for people to be able to update, and I won't have to finagle multi-arch images 😃
As the PR from last TWIM is still awaiting review, I have once again updated the Docker ARM images for Dendrite for version 0.3.3. As always, they can be found in my docker repo at https://hub.docker.com/u/trslimey
If you didn't catch it already, we did a full announcement this week for Gitter now speaking Matrix 🎉! If you're curious about how we made it and some more technical details, the blog post is a great read: https://matrix.org/blog/2020/12/07/gitter-now-speaks-matrix
In terms of bridge progress, we added support for m.emote status messages which means your /me says hi messages will bridge back and forth properly. On the Gitter side, we fixed the browser notifications so they show properly from the virtualUser instead of the generic matrixbot.
I made an Instagram DM bridge: https://github.com/tulir/mautrix-instagram / #instagram:maunium.net
It's a bit barebones still, but text bridging and backfilling works. The main advantage over mx-puppet-instagram is that it uses the realtime MQTT API instead of polling.
There was a second update from tulir, he added more features as of today:
After the initial announcement on Monday, I added bridging of reactions, redactions and photos in both directions and also typing notifications, read receipts and all types of messages from Instagram to Matrix.
We’re making more progress on implementing Spaces.. On Web, we’ve made progress on creating spaces and switching between them. On mobile, we’ve laid down the foundations in the Android SDK. If you missed it, we gave a preview in this weeks Open Tech Will Save Us.
Social login
We’ve been working on server-side support in synapse for picking an MXID during login with SSO, and also implementing support in iOS to gain parity with Android & Web, to launch together in future.
VoIP
We’ve been working on implementing hold & resume (line 1 / 2) support on Web, iOS & Android. Web has something sneak previewable on develop.element.io!
The new background service has been merged. Messages from notifications will be displayed faster within the app. A TestFlight build for testing will be available tomorrow.
This is a first update regarding a very small project named "axon", aimed at operating the synapse admin API from Python, either as a library or a CLI tool. It is currently in use everyday on our synapse instance for managing users and looking for suspicious rooms, and is being integrated into a prototype Web interface for managing synapse.
Admin API coverage is currently about 50%, mostly focusing on users and rooms management (get, list, update, delete). It is still enough to delete a user, edit an offensive avatar, or run as a cron to periodically purge remote media.
Our main repository: https://forge.tedomum.net/tedomum/axon
Github project mirror for contributing: https://github.com/kaiyou/axon
I asked if there was a GUI:
Not currently, but we are integrating it with another of our tools named "hiboo", which is a general indie hoster user manager (provides SAML & OIDC authentication with config templates for many projects including synapse, and integrates the account workflows and moderation features). Currently it provides room navigation and purging, plus deleting accounts either on moderator decision or when the user deletes her SSO account.
Sounds promising! Synapse Admin would benefit from this kind of tooling...
... so it was a surprise to find another project designed to help in this area!
Well, maybe it's about time for "synadm - a CLI frontend to Matrix-Synapse admin APIs" to be announced more officially. As the name implies it's a CLI tool that eases the usage of admin API commands for Synapse admins. It currently covers everything the room and user API's can do: https://github.com/JOJ0/synadm#implementation-status--commands-list
It can be configured interactively and/or using a config file in yaml format: https://github.com/JOJ0/synadm#configuration
It's configurable whether the responds of the API are shown in pretty printed JSON or in a table format (using Python tabulate).
It's well documented via it's online help and supposed to be quite self-explanatory to the admin.
Any thoughts, ideas, feature-requests are very welcome in #synadm:peek-a-boo.at or as usual by filing PR's or issues in the project repo https://github.com/JOJ0/synadm.
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.
