This release brings together a lot of bugfixes, and also some preparation for support for Lazy Loading and Room Versioning.
We also have, as a great contribution from @vojeroen, SNI extension support! With v0.33.3, Synapse now supports sending SNI over federation for vhosted servers, which resolves this long-standing request.
The Shared-Secret registration method of the legacy v1/register REST endpoint has been removed. For a replacement, please see the admin/register API documentation. (#3703)
TravisR continues to plow through work in documenting, clarifying and confirming the spec. You can check out his project on Github: August 2018 r0, which should give an idea of both the scale of the project and the amount of work which has been done. Rather than list out individual items as I have been, please take a look at that project, and come chat in #matrix-spec:matrix.org if you'd like to contribute.
Bruno has merged his work on lazy loading room members lists, which should mean we see some big performance improvements, especially in larger rooms. You can expect to see that released on /develop soon.
He has also just started to work on the riot redesign, and has begun on some of the more visible changes like resizeable panels:
Seaglass is now a very usable and stable client on macOS. neilalexander has been very active this week:
Seaglass has had various updates, including the groundwork for joining and leaving channels, LOADS of crashes fixed, some more work done on avatars and E2E encryption has been fairly well road-tested now
Still need to complete UI for device verification and setting E2E but it works fine in existing channels
Quaternion has gained a new way to highlight mentions - with tinted background instead of colored text. Also, the majority of work on rooms grouping is done, and the current master branch features the roomlist grouped by tag (but rooms under each tag are pretty much out of order so it's not really ready for daily use yet).
Quaternion is looking for a macOS packager - if someone has the chance to help out in this area, speak to kitsune in #QMatrixClient.
Arne came at us with the v0.2.1 release of Palaver:
A few days back Palaver has been moved to Gitlab. And I have since released v0.2.0 and v0.2.1. A runnable jar-file of the latest release can be downloaded at https://gitlab.com/MrCustomizer/palaver/tags/v0.2.1. The biggest changes in v0.2.x are the replacement of all the web views with native JavaFX components (as I don't feel comfortable embedding a whole browser stack in a desktop application) and support for read markers. There is a short YouTube video demonstrating the read marker implementation:
Matrique now has a (basic) room management panel, a working emoji picker, an unread marker and supports playing "m.audio". It should be available at Flathub any time.
ma1uta is continuing to make progress on his Java-focused collection of APIs and SDKs, he's eagerly awaiting the r0 release of the spec (aren't we all!)
Jeon (https://github.com/ma1uta/jeon) (client2server and application api) has released on the Maven Central Repository with version 0.4.1. The next goal: the stable release of all apis 1.0.0 after the Matrix spec will be released (I hope it will be soon :))
Jmsdk (https://github.com/ma1uta/jmsdk) the client and bot SDK have released on the Maven Central Repository.
Gene (https://github.com/ma1uta/gene) the lightweight api for android has released on Maven Central Repository with 0.2.1 version.
So, everyone can use this libraries without additional settings and additional repositories.
Matrix-Jabber-Bridge (https://github.com/ma1uta/matrix-jabber-java-bridge) the double-pupped bridge between the Matrix and Jabber. I am still working on it and I think it will be released in a few weeks.
Ananace has tagged and released the next development version of the Ruby Matrix SDK - 0.0.3. He has plans to "finish up documentation and unit testing", with the aim of making a v1.0.0 release.
tulir has a new, yet-to-be-revealed project, and in support of this he's been working again on mautrix-appservice-go:
mautrix-appservice-go is a bit more active again: it now has an initial intent API similar to the one in mautrix-appservice-python (which in turn is based on the intent API from matrix-appservice-bridge).
No release this week, but Synapse has been progressing:
Python 3 port continues at pace, we expect to have a beta to test in monolith mode rsn (Hawkowl leads this)
Erik has been working on some federation API refactoring to make matrix.org snappier and hopes to have the new state resolution algo ready to go if not deployed late next week
Richvdh has been looking at performance, as well as spec PRs/ Next week will be r0 work
Many Synapse maintainers are also doing huge lifts on development of the spec.
Half-Shot took a rare 30-minute window away from bridge maintenance to add Matrix support to ntfy. ntfy describes itself as
A utility for sending notifications, on demand and when commands finish
but in fact, you also send notifications whenever you like by calling ntfy send from anywhere you'd normally execute shell commands. This will make it really easy to integrate Matrix notifications into any other application!
Well, it may well be the end of the Julian's GSOC 2018 experience with the Fractal project, but I think Google will continue to run the programme. Check out Julian's experience (and the large number of issues resolved!) in this blog post.
This weekend Neil and I will be representing Matrix at OggCamp, "an unconference celebrating Free Culture, Free and Open Source Software, hardware hacking, digital rights, and all manner of collaborative cultural activities", if you will be there, come find and chat to us. We'll be the two nerdy-looking guys, so we should be easy to spot.
But for now, you can watch Neil host Matrix Live below (using the fan-favourite format of walking around the office), and come chat to us in #twim:matrix.org
As part of an overhaul of the documentation surrounding Matrix, I'm planning to launch a "Community Guides Index". This will be a page or section on Matrix.org with links to useful and informative documentation hosted elsewhere. If you have or know of informative articles, please let me know, or share them in #TWIM:matrix.org.
room settings (history/join rules and changing aliases/addresses)
loading member list in rooms
some starting work on loading avatars
various UI and stability tweaks!
🔗Quaternion: new redacted message handling options
Many of you will have seen the incredible volumes of spam plaguing Freenode over the last few weeks. Kitsune has added new features to Quaternion to help:
In response to the recent spam deluge from Freenode Quaternion has got an option to tidy up your timeline after all the spam-cleaning: you can hide all redacted messages or just those that came from recently joined users (along with the join message). So as long as the spammer gets moderated, it can become inexistent for you.
The experimental code doing that will eventually be moved to libQMatrixClient for the benefit of Matrique, uMatriks and other clients based on the library.
This is especially cool: moving functionality to the lib for the benefit of other projects makes me very happy. :D
Eisha and Julian finished their GSOC 2018 Fractal involvements this week, and Eisha has a blog post recounting her experience: My Final Report for GSOC 2018. Julian will have his ready too.
Big updates are on the horizon for both iOS and Android, with 0.7.0 of iOS headed to TestFlight today with a release due once it's through beta & AppStore review. More details once the releases are out!
Meanwhile on Riot/Web, Lazy Loading members is pretty much complete - just writing end-to-end tests to ensure that encryption still works well when lazy loading is enabled. Next up is actually progressing the redesign at last!
MSC1425/MSC1501 richvdh has been thinking about Room Versioning
A summary in his words: "room upgrades are implemented by creating a new room, shutting down the old one, and linking between the two"
MSC1497 thorough discussion happening against Matthew's proposal for Capabilities support in the CS API
MSC1442 though you may have seen it previously, I recommend anyone who is able to take a look at Erik's "State Resolution: Reloaded" proposal. This documents his "thoughts on the next iteration of the state resolution algorithm that aims to mitigate currently known attacks". It very clearly explains the current problem, and the proposed solution. While heavy, I found it really useful for helping to understand State Res and everything it affects.
MSC1485tulir proposes "Hint buttons in messages", which effectively provide pre-defined responses for users. This is especially valuable for Bots which can only accept a certain range of replies. I'd love to see this implemented, having long ago built a "choose your own adventure" engine using similar features from another messaging platform.
Not strictly this week, but we missed it before. ma1uta has been working away on his Java-based Matrix suite. Gene is a more lightweight API implementation than Jeon, covering all of the current C2S spec. A big motivation is to be able to use Gene on Android, which is not possible for Jeon due to it having more dependencies.
The Ruby Matrix SDK now has auto-generated, proper documentation, thanks to Ananace. v0.0.2 is the current release, but it's under active development and v0.0.3 is expected presently.
🔗Telegram Puppeting on t2bot.io with mautrix-telegram
This is a public trial to see how the bridge copes with multiple people puppeting their accounts. Of course, you don't need to puppet your account unless you want to.
For more information on how to set this up, please visit https://t2bot.io/telegram
As part of this project, mautrix-telegram 0.3.0 release candidate was released.
vabd, from the Informo project, arrived to say they have produced "a set of SaltStack states that includes deploying fully working Synapse homeservers: https://github.com/Informo/salt-states"
They introduce the Informo project:
Informo's a project (still a work in progress, currently) that aims at bypassing censorship of information on the Internet, by basically having news items go through a decentralised and federated network made of Matrix homeservers. Since we need to host nodes to this network (at least for testing purposes), we've worked on a working and automated infrastructure using SaltStack, which involved hand-writing a few SaltStack states, including states handling the installation and configuration of working Synapse homeservers. In the spirit of giving back to the community, we're publishing all of those hand-written states (available at the GH link above) under the GPLv3 license. If you want to discuss with us about what we're doing, or this topic specifically, please join us in #discuss:weu.informo.network ?
The project is still pretty much a WIP and the technical specifics (even the ones we already implemented in our projects) are still under discussion and subject to changes (as mentioned in the GH repo's readme). All I can add for sure to what we already say is that we'll be working in partnership with NGOs to promote the project in countries where the press is heavily censored, and we're planning on implementing a cryptographic verification chain of some sort to reduce the risk of intentional disinformation.
The release focuses on performance, notable highlights include reducing CPU consumption through speeding up state delta calculations and reducing I/O through lazily loading state on the master process
Separately work continues on our python 3 port and we hope to have something concrete to trial very soon – we're really excited about this and expect step change improvements in CPU and memory use.
Latest synapse is now available on Debian thanks to andrewsh.
This is not from this week at all, other than that it was new information to me. Actually it's ancient, matrix-wise, but I think it's interesting for those who don't know! Although Riot doesn't have an interface for adding custom room tags ("Favourites" and "Low Priority" come by default), Matrix supports arbitrary strings as room tags, and will display them if you add them via another CS API call. To facilitate this TravisR created a small script, tag_room.sh, which makes it very simple to set your own room tags.
That's all folks! Remember, lots of progress is happening with the Spec, if you want to be involved or follow along the best place to start is by joining #matrix-spec:matrix.org.
No Matrix Live this week due to vacation and general scheduling fun; sorry!
If you have documentation or articles related to matrix, let me know!
Folks, it's release time, Synapse 0.33.2 has landed.
The release focuses on performance, notable highlights include reducing CPU consumption through speeding up state delta calculations (#3592) and reducing I/O through lazily loading state on the master process (#3579, #3581, #3582, #3584)
Separately work continues on our python 3 port and we hope to have something concrete to trial very soon - we're really excited about this and expect step change improvements in CPU and memory use.
Finally we have some ground work for upcoming room membership lazy loading, there is nothing to see here as yet, but rest assured we will make a lot of noise as soon as it is ready. Stay tuned.
Make /directory/list API return 404 for room not found instead of 400 (#2952)
Default inviter_display_name to mxid for email invites (#3391)
Don't generate TURN credentials if no TURN config options are set (#3514)
Correctly announce deleted devices over federation (#3520)
Catch failures saving metrics captured by Measure, and instead log the faulty metrics information for further analysis. (#3548)
Unicode passwords are now normalised before hashing, preventing the instance where two different devices or browsers might send a different UTF-8 sequence for the password. (#3569)
Fix potential stack overflow and deadlock under heavy load (#3570)
Respond with M_NOT_FOUND when profiles are not found locally or over federation. Fixes #3585 (#3585)
Fix failure to persist events over federation under load (#3601)
Progress on the spec has been motoring since TravisR dived (dove?) into it full time a few weeks ago - the Federation API r0 megathread bug that tracks progress on filling in the gaps on the S2S API is clearing its checkboxes at an impressive rate.
MSC1466 Erik proposes a soft_logout field to be added to the body of 401 responses, to better help handling of encryption keys. Check the proposal notes
MSC1452 agreement has been reached on Homeserver Warning Messages
We're going with pinned messages (option 2) and room tags (option 5) as that seems to be where the consensus is: it re-uses existing bits of the spec and room tags also help clients that don't know about this specific room tag to handle the room the right way
MSC1426/MSC1421 Discussion about the review process itself
MSC1425 Room Versioning
It's likely that in the immediate future we'll want to change the properties of rooms in a way that will not be compatible with existing servers - for example, changing the rules for event auth or state resolution, or changing the format of an event id.
MSC1318 Documentation describing the anticipated Open Governance of Matrix.org (aka, Matrix.org Foundation)
The maintainers of the Matrix Python SDK are mulling some major changes to the library. In particular, the desire to use await / async syntax means they are considering making Python 3.5 the minimum supported version. Go chat about this change and comment on the proposal issue.
libQMatrixClient and Quaternion have gained ability to resend and discard unsent messages.
this means if Quaternion could not, after several attempts, deliver a message, a user can click "Resend" and it will try again
On the subject of libQMatrixClient, it's exciting that Konversation, the KDE IRC client, may in future start to use libQMatrixClient for Matrix support!
Matrique now has a Flatpak repo. It is the nightly build of the master branch. You can add the repo by typing flatpak remote-add matrique https://b0.gitlab.io/matrique-repo/matrique.flatpakrepo and install it by flatpak install matrique org.eu.encom.matrique
As it is still Alpha quality, bugs are expected. Feel free to open an issue if anything goes wrong!
Half-Shot has been working tirelessly on the IRC bridge lately, so I wanted to update on his recent successes:
I've recently been working on mitigating the effects of a netsplit on the IRC bridge, and optimising it to start and run faster. This week I trimmed down the heap usage (where the memory usually goes) to just under a gigabyte on my 10,000 matrix user test bridge. Previously it could spike to as much as 3.5GB. This optimisation is still in a testing phase but results are looking positive.
For reference here is the memory usage of the Freenode process during startup:
And here are the results of my local test bridge before and after the change:
Before:
After:
We also made some internal changes to the appservice-bridge to cache the joined state of all the bridge users and therefore avoiding joining rooms which saves us some time on startup.
Synapse 0.33.1 is out now as a security update release. Please update if you haven't already - it fixes two issues concerning event visibility where if you knew the event ID of an event you could read it even if you didn't have access to it; we don't believe these have been exploited in the wild, but you will definitely want to upgrade now.
Meanwhile the Python 3 port is progressing well (all sytests now pass in Python 3, i think!), and intrepid folks are starting to experiment with running it in production.
Meanwhile, Matthew & Amandine have been in San Francisco for the 2018 Decentralised Web Summit - so this week's Matrix Live is live from SFO and gives a quick overview of the sort of things we got up to! Some of the sessions are already online thanks to the (somewhat unreliable) live stream (e.g. here's Muneeb (Blockstack), Amandine, Danielle (Dat), and Zooko (Zcash) talking about their respective governance models & growing pains over the last 2 years: https://youtu.be/tsz3ffrJDpw?t=12133). The summit was a massive success, with lots of discussions about decentralised reputation, UI/UX for decentralised apps, metadata-resistance, the balance of P2P versus decentralised-servers, etc. Hopefully some of the conversations we had will result in some major improvements to Matrix in the future!
Edit: Here are the slides for our "Diving into Decentralised Communication" workshop, for those interested in a comparison between Matrix/SSB/Mastodon/Status/Vuvuzela/Briar. They're pretty minimal, as they just formed a framework for discussion, but might still be of interest.
We have patched two securities vulnerabilities (details follow), we do not believe either have been exploited in the wild, but recommend upgrading asap.
Following on from the previous post, we have an update from zil0 on his GSoC project, which entailed implementing E2E support in the Matrix Python SDK.
The goal of my project is to implement Matrix's end-to-end encryption protocol in Python, as part of matrix-python-sdk. My mentors are Richard van der Hoff (richvdh) and Hubert Chathi (uhoreg).
It was easy to get started on the project, since the simple parts came first (adding API calls), and then the whole process to follow is documented in an implementation guide, while there is also the reference implementation in JavaScript. And most importantly, the community is nice. :)
Some parts of the work consist in wrapping around the cryptographic primitives implemented in libolm (via Python bindings), in order to handle encrypted events. Others are less straightforward, such as tracking device lists of users, or finding the right way to persist keys and related data between startups.
An interesting aspect of this project is that I am working on a new part of the Python SDK, while also having to integrate with existing code, which is a cool balance between freedom and guidelines.
As the encryption documentation is a bit outdated and incomplete, one (fun) difficulty is to look for information across old issues, Gdocs and source code (and asking my mentor when in doubt). For anyone trying to implement E2E, it should be better by the end of the project, as I am currently working on documenting the missing bits.
I have had a great experience so far. Working on an open source project differs from my previous coding experiences, as people are actually going to use what I write! I have learnt to think about the best design from a usability point of view, discuss different approaches, and I had to write tests and document my code, which sadly is not something I do on personal projects. I enjoyed reviews, and the discussions they led to. And of course I have learnt quite an interesting lot about the E2E voodoo, along with some new Python tricks.
Currently, the implementation is in a working state. Some of the code is merged, and some is awaiting review. It is possible to try it here before everything is merged.
The project will be finished in about one week, after some tidying up and when I release device verification and key sharing, which should be the last missing features compared to Riot.
As you may know, for the last few months anoa (Andrew) and APWhiteHat have been working on Dendrite, the next generation Matrix homeserver, written in Go. We asked for an update on their progress, and Andrew provided the blog post below. Serious progress has been made on Dendrite this summer!
Hey everyone, my name is Andrew Morgan and I've been working full-time over the summer on Dendrite, our next-generation Matrix homeserver. Over the last two months, I've seen the project transform from a somewhat functioning toy server to a near-production-ready homeserver that is working towards complete feature support. I've appreciated the thought put into the project since day one, and enjoy the elegance of the multi-component design. Documentation is fairly decent at the moment, but comments are plentiful throughout the codebase, while the code itself tends towards simple and maintainable rather than complex and unmanageable.
The main focus of my time here has been on the implementation of application service support for Dendrite. Application services are external programs that act as privileged extensions to a homeserver, allowing such functionality as bots in rooms and bridges to third-party networks. Supporting application services requires a few different bits and pieces to be set up. Currently all planned features have a PR for them, with the bold items already merged:
Sending events to application services
Support user masquerading for events
Support editing event timestamps
Support room alias querying
Support user ID querying
Support third party lookup proxying
As you can see a decent portion of the functionality is already in master! The rest will hopefully follow after some further back and forth.
I certainly haven't been going at this all on my own. Alongside extensive help from Erik, who's been mentoring me, our resident Google Summer of Code student, APWhiteHat, has been tackling feature after feature in Dendrite wherever he can find them. Application services received a good deal of help on client-server endpoint authentication side, however, APWhiteHat has mostly been focusing on federation and some other very useful pieces. While his GSoC period still has a week or so before its conclusion, he has so far implemented:
Idempotency to roomserver event processing to prevent duplication
Username auto generation
Tokens library based on macaroons
Lots of left-over federation stuff: state API & get missing events being the major ones
AS support to clientapi auth
Typing server: handling of PUT /typing by clientapi
More typing server stuff on its way
From my perspective, APWhiteHat was an excellent developer to work with. He asked good questions and was quick to answer any myself or the community had as well. His code reviews were also very comprehensive. I learned a lot from working with him and everyone else :)
Placing any large server into a production environment requires extensive monitoring capabilities in order to ensure operations are running smoothly. To that effect, Dendrite has been both the addition of OpenTracing and Prometheus support. Prometheus, also used heavily in Synapse, allows a homeserver operator to track a wide range of data including endpoint usage, resource management as well as user statistics over any given range of time.
In Dendrite, we are taking this one step further by introducing OpenTracing, a language and platform-agnostic framework for tracking the journey of an endpoint call from incoming request to outgoing response, with every method, hierarchy change and database call in between. It will be immensely useful in tracking down performance issues, as well as providing insight into the most critical paths throughout the codebase and where we should focus most of our optimization efforts on. It also comes with a lovely dashboard courtesy of Jaeger:
We've also seen some encouraging interest and development work from the community in the past couple months. While PR review from our own side is admittedly slow due to our focus on getting the foundational work in place, that hasn't stopped both old and new developers from sending in PRs and performing code reviews. A huge thank you to everyone involved! From this we've gotten API implementations and application service fixes from @turt2live, an end-to-end encryption implementation from @fadeAce, filtering support from @CromFr, and some PRs and numerous helpful review comments from @krombel.
We've also started to see some people running Dendrite in live environments, which is incredibly exciting for us to see! While Dendrite is not considered production-ready yet (though it moves closer every day), if you are interested in giving it a go please consult the quickstart installation guide. We look forward to any feedback you may have!
It means you can log in to the bridge with your Matrix account to make messages you send from other Telegram clients appear from your Matrix account.
It can also be used to enable bridging of ephemeral events, which synapse doesn't send to appservices (read receipts, typing notifications, presence).
Also, the bridge has a new HTML parser which should be much better than the old one. It might have caused some new bugs though (like m.emote bridging breaking)
I've been slowly working on matrix.org the last couple of months, updating the FAQ, updating content and UI/appearance of try-matrix-now. As you may know, the FAQBot, created and maintained by Coffee, uses try-matrix-now for it's data, so Coffee updated the bot to start to use some of the new fields.
The final puzzle piece needed for FAQBot has been put into place: https://gitlab.com/Matrixcoffee/extract-web-to-org This is the bit that grabs "Try Matrix Now!" and turns it into questions that FAQBot can use. While I was working on that bit of code anyway, I also added support for the new 'home', 'repo', 'room' and 'language' fields. FAQBot will now give more and better information accordingly. For example, it is now possible to ask, "where is the Riot Android source code?" although it is generally better to just ask "where can I find Riot Android?" which combines several fields into a single answer. 4 of 7 items are now completed: https://gitlab.com/Matrixcoffee/FAQBot/issues/2 and the remaining 3 items before FAQBot's release are just the final review and integration tests.
Half-Shot has been working stridently on the Discord Bridge lately, and the project has now attracted a second maintainer:
We've got a new member of the maintainer crew in discord bridge land (bringing the total count to 2.) I'd like to welcome Sorunome :). They are going to be helping review the influx of PRs, chew some issues and be a point of contact in the community. They've already filled my PR queue up and it's going to help us move even faster!
Bruno, the latest and greatest addition to the [riot-web] team, has been working on configuring end to end unit tests. His scripts now install synapse from the metal, install riot and then run a test suite. Take a look at the animation below to get the idea!
Alexandre Franke tells us about new features in Fractal 3.29.5, and how the project has benefited from GSOC 2018 contributors:
Fractal got a big new release 3.29.5, which includes Eisha's multi-line input (with markdown syntax highlighting) and Julian's room details redesign, as well as his refactor on avatar code which leads to a perf boost.
🔗Ananace: Grafana webhook for Matrix notifications
Ananace, always working on sysadmin tooling with matrix, comes back with a new tool: Grafana webhook for Matrix notifications. This release is described as "the very first 'It doesn't crash instantly' version", but this is surely a useful project.
kitsune had a surprising week while working on his QMatrix projects:
/me accidentally found a year-old feature branch in his Git and thought of rebasing it in order to eventually continue working on it. As a result, libQMatrixClient and Quaternion master branches support local echo from today. Too bad the same trick doesn't work for E2EE.
Hawkowl is running the first ever Python 3.6 synapse! RAM usage looks to be 2-3x less than on Python 2.7. Still work to be done to merge all the PRs though.
Landing all the Lazy Loading patches; 3 down, 3 to go
Gathering feedback on the state res prop - thanks to uhoreg for wading through it!
Catching up Lots and lots of PRs
Implementing room versioning and gathering feedback on the MSC
Perf fixes - optimising current state res a bit & fixing sync performance
=> End-to-end message latency on matrix.org has been improved by 3-5x over the last few days(!!!)
First of all: we've just released the first draft of the proposal for our next generation State Resolution algorithm as MSC1442 (State Resolution: Reloaded). This is the result of a massive amount of work from Erik - if you are at all interested in the problems that state resets have plagued us with, then you will want to read the proposal and please comment on it!
The next step on State Resolution: Reloaded (once approved) is to be able to actually roll it out - and to this end, richvdh has proposed MSC1425 (Room Versioning proposal). This was published at the beginning of the week but we haven't had any feedback yet - again, please read & give feedback as the intention is to start working on this as soon as possible! Matthew's also been updating the Lazy Loading proposal (MSC1227).
Meanwhile, the Matrix Spec is now awash with activity, lots of work from TravisR, Cadair and others to accelerate progress. Take a look at the proposals list to stay up to date, or straight to the matrix-doc repo and #matrix-spec:matrix.org room to get the raw activity.
Finally, discussions relating to the spec proposal process itself have attracted attention: MSC1426 and MSC1421, and we're already trialling the new process (using Github PRs rather than Google Docs) in MSC1442 (State Resolution: Reloaded) already.
nheko 0.5.1 is out, and it's great! Get a version for your platform from bintray.com. I've been using it for the last week or so (on macOS) and found it very stable and usable. mujx commented that "highlights were encryption support & desktop notifications on all platforms", but you can get much more thorough notes from the release notes.
It's been several weeks since we mentioned Plasma, but work on the C2S parts of the spec implementation have been happening quietly behind the scenes. Project lead Nico said recently:
I've updated the CI test server with the latest snapshot version of plasma. createRoom and invite C2S endpoints are fully implemented and should work as expected.
kitsune presented an introduction to Matrix (for a technical audience) at the Tokyo Linux Users Group - you'll need to skip to 1h41m16s into the video.
🔗GTAD pulls in description and summary fields from the API
kitsune continues working on GTAD, and this week has started automatically including docs in libQMatrixClient:
GTAD is now aware of description and summary fields in API descriptions so you can use them with Javadoc/Doxygen. As a result, libQMatrixClient master branch now enjoys doc-comments throughout its CS API layer - the rest of the library builds in envy.
SimpleMatrix is my approach on making an Android App that is more easy to use than the official one in Terms of UX and UI. Planned is also a Android Wear App within this App for mostly Notifications.
SimpleMatrix is planning to use matrix-java-sdk, but for now is a visual mockup, it doesn't currently connect to Matrix.
After lots of begging, frustration and eventually an offer of a free lunch (thanks Anoa): I give you Discord DMs. This first cut bridges over existing regular and group DMs to Matrix. In the future we will also allow you to create DMs from Matrix so that you can contact users without even logging into Discord. With thanks to the #discord:half-shot.uk community for helping shape this feature!
Currently this is in PR form but is very likely to make it into the 0.3 release of matrix-appservice-discord.
For those who (want to) use Foonetic IRC channels, Half-Shot is here for you! Previously this bridge had been down due to invalid certificates, but this is now resolved.
Synapse 0.33 landed on Thursday, boasting 2x speed-ups for /sync and (briefly) meaning that the matrix.org homeserver felt impressively snappy and fast! Ironically traffic levels promptly grew again such that the synapse master process is now the bottleneck once more, but between incremental state res, python 3 and upcoming room-sharding work we should see the performance fixes continuing to come! Meanwhile, lots of PRs in the queue for Synapse 0.34 - including Lazy Loading support as per (MSC1227), and a whole new set of stats functionality for tracking per-room and per-user stats.
Lots of activity in the build up to Riot/Web 0.16 - merging the new Slate rich text editor to /develop (try it now!), upgrading Jitsi and turning it on by default (at last!! - again, try it on /develop, although you'll have to enable it in Labs). We'd be particularly interested in how Jitsi is behaving, as so far for us it's been unrecognisably improved over the previous deployment.
Meanwhile, lots of work on Lazy Loading members on Riot/Web and Riot/iOS, and lots of stability perf work in general across mobile.
