The Matrix Holiday Special!

25.12.2015 00:00 — Events Matthew Hodgson

Hi all,

We've been pretty bad at updating the blog over the last few months with all the progress that's been happening with Matrix.  Whilst Matrix rooms like #matrix:matrix.org and #matrix-dev:matrix.org have been very active (and our twitter account too), in general we've ended up spending way too much time actually writing software and not enough time talking about it, at least here. When a blog goes quiet it normally means that either the authors have got bored, or they're too busy building cool stuff to keep it updated. I'm happy to say that option 2 is the case here!

As a result, there's a huge backlog of really cool stuff we should have talked about. Hopes of writing an Advent Calendar series of blog posts also went out the window as we set Christmas as an arbitrary deadline for loads of work on Synapse, the Matrix Spec and matrix-react-sdk.

So, to try to break the impasse, here's a slightly unorthodox whistle-stop tour of all the amazing blogposts we would have written if we'd had time. And perhaps some of them will actually expand into full write-ups when we have more time to spare in the future :)

End to End Encryption Update

One of the great promises of Matrix is to provide End-to-end encryption as part of the baseline standard (configurable per-room). In practice, our progress has been a little non-linear - we started writing an Axolotl ratchet implementation in C++14 (with a pure C API) named Olm back in February, and then finished it off and wired a basic 1:1 proof-of-concept implementation into matrix-react-sdk in June. We then announced Olm back at the wonderful Jardin Entropique conference in Rennes:

Jardin Entropique

You can read the full presentation that we gave at https://matrix.org/~matthew/2015-06-26 Matrix Jardin Entropique.pdf - and you can even play with a very basic test jig at https://matrix.org/~markjh/olm/javascript/demo.html which uses an emscripten compiled version of Olm in the browser to put the ratchet through its paces.

Things then stalled for a bit, but as of this month they're moving again, and if you're interested in the progress you can read all about it at:

The main stuff remaining is basically key management (in Synapse and the matrix spec), group conversation ratchets, and UX for wiring it properly into various Matrix clients. We expect to make progress on this over the next few months :)

Meanwhile, huge kudos to Tor who was crazy enough to add the basic 1:1 Olm ratchet to Weechat before we'd even finished writing our test jig!

Lean DUS

A few days after Jardin Entropique we made it to Lean DUS - a great tech meetup in Düsseldorf organised by Sipgate, who were kind enough to invite us to speak. This was a chance to give a full update on Matrix (as of July!) and talk some more about Olm and plans for end-to-end encryption. This one got recorded - and you can see it below. There's also an official page with full videos, slide deck and photos up at https://www.leandus.de/2015/08/weil-und-hodgson/.

Lean Dus #9 - End to end encryption for decentralised communication mit Matthew Hodgson from sipgate on Vimeo.

New Matrix Bridges

Somehow we've failed to blog about the amazing matrix-appservice-bridge Node framework which we've built as general purpose infrastructure for building Matrix Application Services which act as bridges between existing networks and comms solutions and Matrix. The architecture here looks something like this:

matrix-appservice-bridge

...and the goal is to end up with something like this:

bridge2

matrix-appservice-bridge is still in development, but there are a bunch of really cool bridges already using it - and a great howto that shows how you can use it to write a Matrix{'<->'}Slack bridge in under 100 lines of code.

  • the Matrix/Verto Bridge uses it to hook FreeSWITCH up to Matrix - currently used to provide multiway video and voice conferencing for Vector. It could be easily extended to do generic Matrix{'<->'}SIP or Matrix{'<->'}anything-that-FreeSWITCH-can-speak though.
  • a basic Matrix/Slack Bridge, which works well enough for hardcoding bridges between specific Matrix and Slack rooms.
  • matrix-appservice-respoke - a crazy experiment that bridges Asterisk to Matrix by implementing the Respoke API such that Asterisk can connect to Matrix using chan_respoke.
  • matrix-appservice-purple - another crazy experiment that hooks libpurple up to matrix-appservice-bridge such that *any* network that libpurple can talk to can be bridged into Matrix. So far we've experimented with Lync, Skype and Facebook (and AIM(!)) and it works - but it needs a lot more love to be usable other than as a toy.

Meanwhile, there's also:

As of right now our work on bridging has been on hiatus for a month or so, and we would love support from the community in advancing and extending the stuff we've built so far. Otherwise we'll get back to it ourselves in the new year.

Astricon 2015

We had a lot of fun in Orlando in October at Astricon 2015 - we put together matrix-appservice-respoke (see above) for our talk and Dangerous Demo in a desperate 24 hour hack and it even worked! The judges were kind enough to give us the "Swan Award" prize in the dangerous demo shoot-out for the glossiest demo :)

2015-10-15 Matrix Astricon swan award

The slides for our 'Bridging Asterisk to the Matrix Ecosystem' talk are downloadable here.

Pidgin!

We also implemented a basic libpurple plugin for Matrix - adding Matrix support to any app like Pidgin or Bitlbee that uses libpurple. (You could in theory even use it with matrix-appservice-purple to bridge from Matrix to Matrix, but that'd be silly :). It supports basic functionality and uses the new 'v2' APIs for syncing to Matrix. Adventurous libpurplers can go check it out and experiment with it from https://github.com/matrix-org/purple-matrix - feedback welcome.

OpenWebRTC Support on iOS

We went and hooked OpenWebRTC up to matrix-ios-sdk so that iOS Matrix apps can use the OpenWebRTC stack from Ericsson Research for VoIP and Video. Apparently we haven't written it up fully yet, but you can find the code at https://github.com/matrix-org/matrix-ios-openwebrtc-wrapper for those interested in using OWR with Matrix!

Debian Repository for Synapse

We built a 3rd party Debian package repository for Synapse... and then forgot to tell anyone about it, other than buried in the Synapse readme! Well, it exists, and intrepid debianers should go check it out at http://matrix.org/packages/debian/.

TADSummit

In November we attended TADSummit in Lisbon - a great event for folks hacking on telco applications and the telcos themselves. Apparently we failed to do a writeup, but we had a wonderful time: highlights included sitting down with Maarten Ectors from Canonical to wrap up Synapse as an Ubuntu Snappy app such that anyone in the Ubuntu Core ecosystem can trivially run a Matrix homeserver, and demoing it as part of the Dangerous Demos track there. We also gave a 'Matrix: One Year In' talk to summarise what we got up to in 2015.

Matthew & Maarten 2015-11-17 Matrix TADSummit

WebRTC Paris

Whilst on the subject of conferences that we forgot to write up - we just got back from WebRTC Paris, where we demoed the latest & greatest Matrix clients and bridges, hung out with the OpenWebRTC guys and gave another ecosystem update. You can see the slides at https://matrix.org/~daniel/Matrix- One-year Status Report.pdf.

WebRTC Paris

New Clients and App Services

There have been a flurry of really interesting new clients and other projects which certainly deserve whole blog posts of their own!

There's Tensor from David A Roberts - a multiplatform native client written in QML that heavily leverages the matrix-js-sdk:

tensor

There's matrix.el from Ryan Rix - a native Matrix client for Emacs! You can read all about the whys and wherefores here.

mclient

There's also loads of cool stuff that Ryan's been doing with Matrix on his blog - including Polynomial - a decentralised webring built on Matrix (yes, webrings were and are cool, ok!?!), and his Matrix-powered Body Computing System. Also, some philosophical posts on the benefits of Matrix which give us some hope that we're on the right track!

Then there's Power Take-Off from Torrie Fischer - an early lets-IRC-clients-connect-to-Matrix project in Rust...

...and there's Morpheus from Christine Dodrill (Xena) - a Matrix client and bot framework for Haskell; part of a more over-arching IRC{'<->'}Matrix unification project. Xena also wrote a great call to arms for Matrix :)

Very recently there's the Ruma project from Jimmy Cuadra - an ambitious mission to build Matrix components (up to and including a homeserver) in Rust!

Other stuff includes a Hubot adaptor from davidar, Bender: an Elixir client and bot library from Dylan Griffith, Jon Frederickson's matrix-xmpp-bridge, rzr's guide to installing synapse on a minnowmax, and I'm sure many others we don't know about or have missed!

Finally, Tor has done an amazing job on weechat-matrix-protocol-script in implementing features like V2 Sync and E2E crypto faster than we've managed to add them in the official client SDKs!

Release Zero of the Matrix Specification

We have made some major improvements to the spec over the last few months: adding in feature profiles and spec modules to better structure the document, and most recently splitting it up explicitly into separate Client-Server, Server-Server and Application-Server APIs, each with a well-defined single global 'release' number for versioning. We started this with a 'r0.0.0' release of the Client-Server API, which consolidates the horrible mess of 'v1' and 'v2' APIs we had previously flying around into a single well-defined version of the spec. Meanwhile the spec is now entirely consolidated into a set of JSON schema and Swagger 2 API descriptors, with a bunch of ReStructured Text for the verbiage - you can find it all at https://github.com/matrix-org/matrix-doc.

The r0.0.0 changelog is exciting stuff - you can see it in its entirety at http://matrix.org/docs/spec/r0.0.0/client_server.html#changelog. Synapse itself will support the full r0 API set in 0.12, which will be released any day now.

We've also switched the Swagger-based API viewer over to Swagger 2.0: http://matrix.org/docs/api. We also rejigged the Matrix documentation website entirely, generating it via Jekyll and adding in a new guides section.

Also, we should have mentioned the existence of Speculator - a golang helper app (source here) which, as the name suggests, renders out copies of the spec as HTML from different branches and pull requests for ease of previewing.

Dendron

Over the last few months we've also started an entirely new project, codenamed Dendron. Dendron is the project to evolve Synapse from the current single-threaded Python/Twisted monolithic homeserver into something with a lot more type-safety, horizontal scalability and high availability. We've mainly been experimenting with different ways of doing this, but the current plan is to split Synapse itself up into multiple services which can each scale independently, and then rewrite some/all of them in languages with better type safety and/or performance or profiling tools.

Some folks may remember a survey that we posted a few months ago asking for the community's thoughts on what languages they'd like their ideal homeserver to be written in, from the perspectives of someone running it as well as hacking on it. Whilst we haven't (at all) based our decisions for Dendron purely on the survey, it was still quite an interesting exercise. And here are the results (maximum 'score' is 5, not 10):

language survey 1 language survey 2

The basic feedback was that from the existing community: folks dislike running Java or Node servers; are okayish with Python, but would prefer native or near-native code (be that C, Rust or Go). Meanwhile, for contributing code, there's slightly more interest in the (relatively) new shinies of Go and Rust. And of course, everyone wanted to plug their own special snowflake language in the 'Others' section, which was mainly a mix of Erlang, Elixir, Haskell, Lisp and Perl :)

This reinforced the choices we were looking at anyway - either Rust (for its safety), or Go (for its simplicity, python-likeness, and concurrency). (We'd also consider Java, but have to concede that the FOSS community doesn't like running it.)

So we looked at the dependencies that Synapse currently has, and the Rust equivalents, and concluded that the Rust ecosystem unfortunately isn't quite mature enough yet to reliably handle the rather large set of complicated deps that we need in a homeserver. Also, nobody on the core team is really a Rust guru yet. Meanwhile, we have at least one ex-Google Go expert in the core team, and in practice it has the edge in terms of maturity. So, right now, we're looking at switching chunks of Dendron to Go where it makes sense. (This is subject to change though depending on how we get on). You should expect to hear a lot more about Dendron in 2016 :)

matrix-react-sdk, Vector, and latest Matrix features

Last but not least: huge amounts of our time over the last year has gone into building matrix-react-sdk - a full set of glossy Web UI components for building super-high quality glossy apps based on Matrix, built on the matrix-js-sdk. This is basically a reaction against the original matrix-angular-sdk and Matrix Console app that we launched Matrix with back in 2014 - which had minimal attention to UI/UX and suffered from major performance problems; it was built purely as the fastest possible way we knew to prototype and demo Matrix in the first place. matrix-react-sdk however has been built for both performance and quality of UI/UX, as well as obviously using all the latest and greatest Matrix APIs. (In fact, the transition from matrix-angular-sdk to matrix-react-sdk is pretty similar to the Synapse to Dendron transition on the horizon - although the latter should be more incremental and less 'rewrite the world').

Meanwhile, as part of our commercial work at our day job (i.e. not as Matrix.org) we've been helping on a glossy FOSS app called Vector which is layered on top of matrix-react-sdk as a thin 'skin' layer of CSS and a few custom components. The intention for Vector is to ensure that Matrix has a flagship glossy client: which it clearly needs, in order to gain credibility and drive uptake of the Matrix standard, and also ensure that the Matrix standard actually does indeed fit the needs for a state-of-the-art collaboration tool.

matrix-react-sdk (and thus Vector) is still in incredibly heavy development - we're going to start a formal beta fairly soon, but as of right now it's still sprouting features and refinements on a daily basis. Meanwhile matrix-react-sdk's APIs are not remotely frozen (we entirely refactored it as recently as a few weeks ago), so not yet ready for use as a general purpose building block.

Some of the stuff going into react-sdk is incredibly cool - recent Matrix stuff that it shows off includes:

  • Animated read receipts. If you haven't seen these, you haven't lived. They are a relatively new addition to the Matrix spec.
  • Full server-side search. We now have full-text search in the Matrix spec, and implemented on synapse both on sqlite and postgres - and now in Vector too. Having good search over all of your chat history makes Matrix *so* much more usable.
  • Video conferencing. We have full multi-way conferencing in Vector via matrix-appservice-verto and FreeSWITCH. The intention is to add this to the core Matrix spec (having first made it a bit more generic) - see the draft spec for details.
  • 3rd party invites. You can now invite users into Matrix by email address as well as matrix ID, and it works. Vector implements this.
  • Room tagging. You can now tag rooms as favourites, low priority, or with arbitrary namespaced metadata. Vector implements this through a swanky drag & drop UI.
  • "V2" Sync API. Now part of the 'r0.0.0' spec, this lets Matrix support much smarter incremental and partial synchronisation patterns. Vector now implements this, meaning that browser windows sync much faster after being offline for a bit, and no longer hammer the user with stale desktop notifications.
  • Accessing 'historical' rooms. Matrix now lets you keep track of rooms you've left, so you can view and search the conversation logs even after you've left the conversation. Vector now implements this (as of Monday!)
  • Tab-complete that doesn't suck. This is a purely client-side feature which landed on Thursday!
  • Roll-overable animated GIFs. 'nuff said.
  • Markdown support. yay!
  • Synchronised read and notification history. This hasn't landed yet (in vector or synapse or even the spec), but finally provides a way to keep read and notification state in sync in realtime across all your clients and a meaningful favicon 'badge' telling you how many notifications you missed!
  • Guest access. This hasn't landed in Vector yet, but it's in the spec and Synapse. It will let folks use Matrix without having to create an account (at least for rooms which support 'guest access' from the public).

If you haven't given Vector a spin, it's well worth heading over to https://vector.im and taking a look.

There's also an Electron desktop version of Vector in progress, contributed by Steven Hammerton at https://github.com/stevenhammerton/vector-desktop (although it's currently stuck on an old release).

Epilogue

Okay, this has got a lot longer than it was meant to be - but hopefully makes up a bit for the lack of comms over the last few months whilst we've been drowning in work on Synapse, Vector, the Spec, Dendron, and everything else mentioned above.

2015 has been an epic year as we've taken Matrix from a very early beta to the advanced stage that it's at now. Obviously there's still a lot of stuff to do though. Right now we expect the focus in 2016 to be:

  • Vector - making sure the Matrix protocol has a flagship glossy FOSS client that normal (non-geek) users can use.
  • Dendron - making Synapse more reliable, scalable and maintainable.
  • Bridging - wiring as much of the rest of the world into Matrix as accurately and efficiently as possible.
  • Federation Spec - finishing and releasing the Server-Server API.
  • End-to-end crypto - finishing it off.

...and obviously continuing to refine and extend the core of Matrix itself with features like threading, editable messages, and possibly even distributed accounts.

There are very fun and exciting times ahead. We'd just like to say a profound thank you to everyone who's supported Matrix this far and helped make this mission possible - whether it's by running clients/servers/services, or writing your own, or filing bugs and feedback on our code or the spec, or telling folks about the project, or paying us to work on it(!), or just by reading this blog post. Hopefully 2016 will be the year where online communication starts to open up and interoperate once again, rather than becoming ever more fragmented and closed.

Thanks for reading - and Merry Christmas, for those who celebrate :)

  • Matthew, Amandine & the Matrix Team.

WebRTC Conference & Expo in Paris

14.12.2015 00:00 — Events Oddvar Lovaas

a4webrtc_2015_v2Matrix will again be represented at the WebRTC Conference & Expo in Paris. Daniel and myself are catching the Eurostar tomorrow afternoon, and the conference will start early Wednesday morning with a panel about WebRTC for Mobile, where Daniel is one of the participants.

I'm sure we will have three days full of interesting talks and discussions (see the full schedule here). There will be demos as well, and Matrix is (of course!) also joining the demo competition. We hope to see many familiar faces - and hopefully meet some new ones as well!

If you are going to the conference, please come and say hello – we will have a stand at the expo (we're table #6 - see map here). And don't miss Daniel's Matrix One-year Status Report at 11.10am on Friday!

See you there!

Matrix at 32C3 Congress!

01.12.2015 00:00 — General Oddvar Lovaas

fairydust Matrix will be represented at the 32nd Chaos Computer Club, Dec 27th-30th, 2015. We hope to be arranging an assembly, where people can come along to learn about Matrix and our recent work on end-to-end encryption, find out what they can use Matrix for - and also do some hacking at the same time!

UPDATE: We've snagged a table for the assembly at: "hackcenter room with C-base, a table along the pathway". In practice only Mjark is there from Matrix and may be moving around, so may be easiest to coordinate meetups via #32C3:matrix.org

The session is free of charge, although you do need a ticket to the Congress itself.

If you are interested, please register by sending an email to [email protected]. All you need for the session is curiosity - but do bring your own laptop if you want to hack as well!

Anyone is welcome to join - it will basically be a fairly open-ended chat about all things relating to Matrix, and a good chance to do some deep digging into Matrix itself.

Hope to see you there!

Matrix Console iOS 0.5.6

22.11.2015 00:00 — General Oddvar Lovaas

In addition to the Android release a couple of days ago, we also released a new version of Matrix Console iOS: v0.5.6!

This release includes a new version of MatrixKit (v0.2.7) that you can take advantage of in your MatrixKit powered app. There are several changes in MatrixKit since the last release, including improved performance, better handling of unrecognized certificates and fixes of reported crash issues. We have also introduced read receipts, improved the chat history display, made room invites more obvious, and fixed a whole lot of JIRA issues.

You can find the full list of changes in the MatrixKit CHANGES.rst and the Matrix Console iOS CHANGES.rst files.

Android Matrix Console 0.5.2

20.11.2015 00:00 — General Oddvar Lovaas

The Android Matrix Console app v0.5.2 is currently in the queue to go live on the Play store!

This release includes:

  • Read receipts!
  • Call ring volume is now based on device ring volume
  • Accessibility tweaks from Peter Vágner - thanks!
  • Better SSL support for older devices
  • We fixed an echo problem in Android{'<->'}Android VOIP calls
  • A ringback tone for placing outbound calls was added
  • Lots of small improvements, e.g. better recent message display and add account dialog
  • Fixed several reported issues/crashes - for the full list look at the CHANGES files in the console and SDK projects

Get it RSN from the Google play store!

Enjoy! And please do let us know your feedback in #matrix:matrix.org!

Synapse 0.11.0 is here!

17.11.2015 00:00 — General Oddvar Lovaas

Today, we are releasing Synapse version 0.11.0. In the last week, we have had two release candidates, and this release also includes changes in v0.10.1-rc1 from October.

New features include a new Search API and better options for logging in (CAS and login fallback support) - thanks to Steven for contributing CAS support. We also introduce room tagging and as usual, there are plenty of improvements and fixes. For the full info, see the changelog below.

To upgrade, go read https://github.com/matrix-org/synapse/blob/master/UPGRADE.rst - to install for the first time, go to https://github.com/matrix-org/synapse/blob/master/README.rst.

Changes in synapse v0.11.0 (2015-11-17) =======================================
  • Change CAS login API (PR #349)

Changes in synapse v0.11.0-rc2 (2015-11-13)

  • Various changes to /sync API response format (PR #373)
  • Fix regression when setting display name in newly joined room over federation (PR #368)
  • Fix problem where /search was slow when using SQLite (PR #366)

Changes in synapse v0.11.0-rc1 (2015-11-11)

  • Add Search API (PR #307, #324, #327, #336, #350, #359)
  • Add 'archived' state to v2 /sync API (PR #316)
  • Add ability to reject invites (PR #317)
  • Add config option to disable password login (PR #322)
  • Add the login fallback API (PR #330)
  • Add room context API (PR #334)
  • Add room tagging support (PR #335)
  • Update v2 /sync API to match spec (PR #305, #316, #321, #332, #337, #341)
  • Change retry schedule for application services (PR #320)
  • Change retry schedule for remote servers (PR #340)
  • Fix bug where we hosted static content in the incorrect place (PR #329)
  • Fix bug where we didn't increment retry interval for remote servers (PR #343)

Changes in synapse v0.10.1-rc1 (2015-10-15)

  • Add support for CAS, thanks to Steven Hammerton (PR #295, #296)
  • Add support for using macaroons for access_token (PR #256, #229)
  • Add support for m.room.canonical_alias (PR #287)
  • Add support for viewing the history of rooms that they have left. (PR #276, #294)
  • Add support for refresh tokens (PR #240)
  • Add flag on creation which disables federation of the room (PR #279)
  • Add some room state to invites. (PR #275)
  • Atomically persist events when joining a room over federation (PR #283)
  • Change default history visibility for private rooms (PR #271)
  • Allow users to redact their own sent events (PR #262)
  • Use tox for tests (PR #247)
  • Split up syutil into separate libraries (PR #243)

Redecentralize Conference - taking back the net

19.10.2015 00:00 — General Oddvar Lovaas

rdc15 This weekend, I went to the first Redecentralize Conference. I thought it was a good mix of traditional tech talks and sessions where we discussed how to make people aware of why the net needs to be decentralised. There were a lot of interesting people and we had some really thought-provoking discussions. Sessions in the main room were filmed and can be found here.

I did a talk on Matrix in one of the tutorial rooms, and it was great to see people with lots of questions and comments in the session. If you missed the talk - or have further questions: the FAQ might have the answer, or maybe the Spec itself - and there's always #matrix:matrix.org where you can find me and the whole matrix team.

At the end of day-panel on the first day, the question "are there any projects that are ready for mass adoption" was posed, and Ira picked Matrix as her answer, which was great to hear. We have come a long way in the last year, and I think Matrix now has "enough" features to be a realistic option for your IM/VoIP and group chat needs.

I really enjoyed redecentralize and hope it will be repeated! Thanks to the redecentralize.org gang for arranging it!

Android Matrix Console 0.5.1 released!

07.10.2015 00:00 — General Oddvar Lovaas

Following from the addition of voice and video calling in the previous release, we have added some new features and fixed more bugs - and released v0.5.1 of the Android version of the Matrix Console app.

Please note that installing this update will log you out of the app and require you to sign in again!

This release includes:

  • Support for self-signed certificates
  • Support for recording and sending video messages
  • We have improved the performance when you resume the app
  • We fixed a bug where a picture/video would disappear after rotation
  • Fixed several reported issues/crashes - for the full list look at the CHANGES files in the console and SDK projects

Get it now from the Google play store!

Enjoy! And please do let us know your feedback in #matrix:matrix.org!

Congrats to our TADHack Matrix Winner!

06.10.2015 00:00 — General Oddvar Lovaas

A weekend of intense prototyping and hacking at TADHack-mini Chicago is over, and we were very happy to again see some really interesting projects using Matrix!

Team 'Vivo' - Nestor Bermudez and Arin Sime - used Matrix, Tropo, and Telestax to create an Apple Watch app that notifies your loved ones when you are having a heart attack. Find more information here - and a recording of their presentation here. This project won the Telestax prize.

Charles Solar and Jiang Shuyang used Matrix and Flowroute resources for a platform independent app called 'Samaritan' which allows users to post help requests like "I got a flat tire!" or "My computer crashed!". Others can then call / text / video chat with them to solve their problem. A video of their presentation can be seen here. This hack won the Flowroute prize.

Vladimir Beloborodov demoed his award-winning Matrix-hack from WebRTC Paris: using Matrix just to set up a WebRTC connection between his iPad and robot, thus proving that you can have a robot with telepresence functions without having to depend on a remote server - see his demo here.

Adnan Baleh, Caterina Lazaro, Javier Garcia, Ernesto G. Grabwosky, Sergio Gil and Marion Le Callonnec - Team 'ProbatioNerds' - created a mobile Matrix app to control the provided Trossen Robotics HR-OS1 Humanoid Endoskeleton robot over the Internet - even making it dance the Macarena! Presentation video can be seen here. We awarded team 'ProbatioNerds' the TADHack Matrix prize - an HR-OS1 - and we hope the team and the robot will keep learning new tricks and moves!

[caption id="attachment_1307" align="aligncenter" width="1024"]Daniel presenting the HR-OS1 to team 'ProbatioNerds' Daniel presenting the HR-OS1 to team 'ProbatioNerds' (Photo courtesy of Alan Quayle)[/caption]

We keep being impressed by the quality of projects developed at TADHacks - remember, in practice you only have around 12 hours to work on your hack. Congrats to all who participated - and thanks to Alan for arranging it!

TADHack Chicago - October 3-4

23.09.2015 00:00 — Events Daniel Wagner-Hall

TADHack ChicagoMatrix is sponsoring another TADHack, this time TADHack mini in Chicago on October 3-4. Come hack something cool together using Matrix, either in Chicago or remotely! At past TADHacks we've seen a robot controlled with Matrix, collaborative web page viewing with Matrix as the underlying protocol, and more.

HR-OS1 Humanoid EndoskeletonAs well as being lots of fun, we've teamed up with Trossen Robotics to offer a HR-OS1 Humanoid Endoskeleton for the best hack using the Matrix standard. The HR-OS1 is a hackable, modular, humanoid robot development platform designed from the ground up with customization and modification in mind. With a Raspberry Pi 2, webcam, wifi, bluetooth, and all of the limbs you expect for a human, there's a lot of scope for exciting projects to be had with it!

I for one would love to ask an open source robot to bring me snacks over chat. (Wow that's a sentence I never thought I would be able to say) I'll be on site, (and also hanging out in on Matrix in #matrix:matrix.org) to help out with whatever creative things y'all come up with - I hope to see you there!

Also in Chicago the following week I'll be giving a tutorial on Federated Identity as well as attending and speaking about the problem of fragmented communication at the IIT Real-Time Communications Conference & Expo.

If you're going to be around, please do say hi - I only recently joined the Matrix team, and there's a lot of people I've yet to meet - I look forward to seeing you at one (or all) of these events!