Salut à Toi v0.7 « La Commune »

goffi 24/07/2019, 22:50 jabber-xmpp-en SàT libre project release

Salut to you!

It is with a big pleasure and a sort of relief that I announce you the release of "Salut à Toi" v0.7.0 (La Commune).

To remind you "Salut à Toi" (or SàT) is an ecosystem of decentralised communication, based on "XMPP" established standard.
It features many functionalities (instant chatting, file sharing, blogging/microblogging, events organisation, forums, etc.) and has the particularity of being multi-interfaced (different "frontends" are available for the web, desktop, mobile devices or even the terminal and command line).

The preparation of this version has taken 3 years. This is the first version we can call "general audience", in other words it is approachable also by those without technical background . Though, there are still some improvements to be done in the frontend and "user experience" level.

I shall not enumerate again all the functionalities with screenshots, you can consult the announcement of the alpha version to do so by yourself. I'd rather explain some major updates, which has been done:

Cagou, the desktop/mobile interface

As promised by our modest crowdfunding, Cagou is the name of the new desktop/mobile frontend (Android only at this moment). To share a little story with you, it is a reference to a beautiful bird, which does not fly, but barks, and is endemically present on the no less beautiful island of New-Caledonia. It is also a nod to Kivy, the framework we are using and from which the name and logo may remind you of Kiwi of New-Zeland.

So, this interface is multi-platforms, not focusing only on instant messaging: you can use it for file-sharing (e.g. the videos/photos between your computer and phone), or as a remote-control for your media player. It is of course planned that it will be able to cope with blogging in the close future.

Cagou is thought to be usable on a little screen, as well in full-screen mode of desktop, and allows the screen division into zones - to, for instance, follow several discussions at the same time.

On android, the application has still some problems with the reactivity and bugs time to time. Lot of problems will be corrected by with Python 3 port. Consider this version as the first one to have you commentaries et propositions.

Cagou sur Android

End-to-end encryption

Of course, SàT has been featuring end-to-end encryption for several years already through "OTR", however this version witnesses the arrival of "OMEMO", an algorithm correcting the issues of previous one (specially allowing sending of offline encrypted messages, or to display them on multi-devices). OMEMO is implemented only for simple conversation ("1:1", between 2 people) at the moment, but the next version will surely cope with end-to-end-encrypted conversations within groups.

Events, photo-albums, forums, ticket-handling, merge-requests

Numerous new functionalities has appeared in this version. You can now create and manage events (e.g. for the family) with the classic list of invited persons et the replies of type "RSVP" (attending, not attending, maybe attending). It is possible to invite people, even though they don't have XMPP account - using the "invitation" accounts which are automatically generated and sent to their emails.

You can create and share the photo albums, a specialisation of file-sharing. The possibility to create one is not yet available from graphic interface, however, this is planned to be improved soon. To consult the photos is simple from Libervia (web interface).

The forum is also in the party, as well as the tickets handling and merge requests. These two last functionalities have been implemented for the project needs, but they are very flexible and can be (in the next version) easily used in a everyday life (e.g. as a shopping lists, to do lists etc.)

All of this take profit from XMPP "PubSub" capabilities, and can benefit of its permission system (we can imagine the shopping list being shared between the family members indicating who bought what).

Remark - to actually benefit from all this it is necessary to use the "SàT Pubsub" service, the project made for the needs of Salut à Toi (but which can be used by all XMPP based programs)

un blog sur Libervia

album photo sur Libervia

Web Framework

The development of Libervia, the web frontend of SàT, has evolved to make it become a web framework. The reason of this evolution is the need of a very flexible interface, one which would allow implementation and testing of new ideas and functionalities easily. The goal is to have a naturally decentralised and federative framework (thanks to XMPP), which integrates simply to the ecosystem. I will speak only briefly about the technical details, but the point is to join Jinja2 with SàT and use PubSub as the database. Also CLI frontend (jp) allows to use the same models to make a static rendering (for instance to generate a static blog or chat archives).

It is with this framework that these above mentioned features were developed, they are organised in "pages" which are supposed to be simple to use and can work without JavaScript (when possible, it is not the case for the chat). The new official website works thanks to the new framework, you'll find there an introductory documentation.

Even More

I won't get too much into details as the updates are too numerous, but though it it worth mentioning that SàT can be also used to store your folders on the server (it can be used as a "component"), or jp, the command line frontend allows manage a lot of things (find or publish an article or blog, send encrypted or non-encrypted message, find someone's avatar, etc.)


Salut à Toi is available on Debian and its derivates, but attention! It is only the case for the backend, the console interface and the command line. By the way, a help to make the Cagou package land there too would be much appreciated.

It is also available on the Arch Linux's AUR repository, and you'll also find there the development versions.

The Flatpak packages allows the easy installation of Cagou, Primitivus (terminal) and jp (command line) on most of GNU/Linux distributions, you can find the links on the main page of the site.
You can of course, use as well pip, the Python packages manager. A simple pip2 install --user sat followed by pip2 install --user cagou and pip2 install --user libervia should be enough. The instructions are available in the site's documentations.

For Android, you can find a APK on this link (unsigned, a definitive version will follow in a couple of days). After the release, I will make steps to make it available on F-Droid, and eventually the "play store".

Even though SàT should technically be working on Mac OS X, Windows and *BSD, however on these platforms it is not yet tested (as I do not have any of this devices). I have had some feed-backs concerning Mac use. If you are interested, help with testing and packaging would be nice.


The principal planned development of 0.8 is the port to Python 3, which is now finally possible, as no more dependency is blocking, and it is the only thing promised for the next version. Lot of big steps are to follow, and it will be inevitable to make some choices. Don't hesitate to give me opinions/feedback in the commentaries.

Video conference

With Jingle already implemented, the video conference has been planned for a long time. It shouldn't be too difficult to be implement it into the web interface (thanks to WebRTC), but certainly would need a lot of work on desktop/Android (to evaluate different options, GSTreamer is the hot candidate at the moment, and integrate with Cagou). This is an important work.

Improving the file sharing

SàT already allows advanced file sharing (more than a simple sending of the files to the server), including a server component. It is very possible, that the future developments will continue in this direction.

share a directory with Cagou

iOS Version

It would be technically possible to use Cagou on iPhone. Though, there are several obstacles to cope with - especially the legal ones (Apple store is not compatible with the current licence, AGPL 3+). Lot of time and investments would be needed. This is clearly not the priority, but keep in mind that an iOS version is doable.

ActivityPub Gateway

With this version, SàT can be used as a "component", i.e. a server service. This possibility can be used to build an ActivityPub gateway, that would allow 2 ways communication with projects using this protocol. There is already somebody working on a similar gateway for Prosody, , so I will certainly wait to see how it evolves before starting it by myself.

Chat Evolution

Though its already functional, the chat can become very complete if we take the time for it. Here, we speak of adding some missing features (like reactions or editing of the last sent message), improving the file handling, copy/pasting of code, end-to-end group encryption, etc.
All this is on the roadmap, the question is whether this is a priority or not.

Improvement of User Experience

This is probably the project which will have the priority, once Python 3 port is done. SàT has already lot of features, but the interfaces need some work to become really user-friendly. I would specially like to work on launch screen and contacts discovery. There are as well lots of "small details " which all together take lots of time, but in total make the user-experience much more pleasant: integration to desktop, file-sharing actions, easier file selection, etc.

Well, so much for the future steps, all of this would take time, but again - your feedbacks are highly welcomed. There are other ideas to think about, but one has to choose her priorities.


Salut à Toi is an huge project with a potential - and it is currently developed by a single person. I have currently only one day a week dedicated to SàT (besides mornings, evenings and nights), the rhythm is very difficult to cope with. In the next months I will seriously study the projects financing possibilities. It will be necessary that I find a way to keep the project on track.

Useful Links

  • official website:
  • documentation:
  • my blog: (I publish there weekly progress notes)

edhelas 24/07/2019, 23:00

debacle 30/07/2019, 12:41

Salut à Toi v0.7 « La Commune »

goffi 24/07/2019, 22:49 jabber-xmpp SàT project libre release planet-libre seenthis

Salut à vous,

c'est avec plaisir et un certain soulagement que je vous annonce la sortie de « Salut à Toi » v0.7 (La Commune).

Pour mémoire « Salut à Toi » (ou SàT) est un écosystème de communication décentralisé, basé sur le standard établi « XMPP ».
Il vous permet de faire de nombreuses choses (messagerie instantanée, partage de fichiers, blogage/microblogage, événements, forums, etc.) et a la particularité d'être multi-interfaces (différents « frontaux » sont disponibles pour le web, le bureau, les appareils mobiles, ou encore le terminal et la ligne de commande).

La préparation de cette version aura pris 3 ans, c'est la première version dite « grand public », autrement dit qui est utilisable par un public qui n'est pas forcément technique, même s'il y a encore des améliorations à faire au niveau de l'interface et l'« expérience utilisateur ».

Il n'est pas question de refaire une longue énumération de fonctionnalités avec captures d'écrans, vous pouvez vous référer à l'annonce de la version alpha pour ceci. Je vais plutôt expliquer certaines nouveautés majeures :

Cagou, l'interface bureau/appareils mobiles

Promis suite à notre modeste campagne de financement participatif, Cagou est le nom du nouveau frontal bureau/appareils mobiles (Android uniquement pour le moment). Pour la petite histoire, c'est une référence à un superbe oiseau qui ne vole pas et aboie, endémique à la non moins superbe Nouvelle-Calédonie, mais aussi un clin d'œil à Kivy, le cadriciel que nous utilisons et dont le nom et logo rappellent le Kiwi de la Nouvelle-Zélande.

Cette interface est donc multi-plateformes, et ne se contente pas de la messagerie instantanée : vous pouvez vous en servir pour transférer des fichiers (par exemple vos films/photos entre votre téléphone et votre ordinateur de bureau), ou comme télécommande pour votre lecteur de médias. Il est bien entendu prévu qu'il gère également le blogage dans un avenir proche.

Cagou est pensé pour être utilisable aussi bien sur un petit écran qu'en plein écran sur un grand moniteur de bureau, et permet de diviser facilement l'écran en zones pour, par exemple, suivre plusieurs salons de discussion en même temps.

Sur Android l'application souffre encore de quelques problèmes de lenteur et même parfois de plantages. Plusieurs problèmes seront corrigés avec le port sur Python 3, aussi considérez cette version comme un premier jet qui permet d'avoir vos commentaires et suggestions.

Cagou sur Android

Chiffrement de bout en bout

Bien que SàT gère le chiffrement de bout en bout depuis plusieurs années via « OTR », cette version voit l'arrivée d'« OMEMO », un algorithme palliant des défauts du précédent (il permet notamment d'envoyer des messages chiffrés hors ligne, ou de les afficher sur plusieurs appareils). OMEMO n'est implémenté qu'en conversation simple (dites « 1:1 », entre 2 personnes) pour le moment, mais la prochaine version verra certainement la gestion des conversations de groupes chiffrées de bout en bout.

Événements, album photos, forums, gestion de tickets, requêtes de fusion

De nombreuses fonctionnalités font leur apparition. Vous pouvez désormais créer et gérer des événements (familiaux par exemples), avec une classique liste d'invités et de réponses types « RSVP » (je viens, je ne viens pas, je viens peut-être). Il est possible d'inviter des gens même s'ils ne sont pas sur le réseau XMPP en utilisant des comptes « invités » générés automatiquement et envoyés à des adresses de courriel.

Vous pouvez créer et partager des albums photos, une spécialisation du partage de fichiers. La création n'est pas encore disponible depuis les interfaces graphiques, c'est une amélioration à prévoir rapidement, la consultation par contre est simple depuis Libervia (l'interface web).

Un forum basique est également de la partie, ainsi qu'une gestion des tickets et requêtes de fusion (« merge requests »). Ces 2 dernières fonctionnalités ont été implémentées pour les besoins du projet, mais elles sont très souples et pourront (dans une prochaine version) facilement être utilisée dans la vie courante (par exemple pour des listes de courses ou de choses à faire).

Tout ceci tire parti des capacités de publication/abonnement (ou « PubSub ») de XMPP, et peuvent profiter de son système de permissions (on peut ainsi imaginer une liste de courses partagée entre les membres de la famille, pour indiquer qui a pris quoi).

À noter que pour en profiter il est actuellement nécessaire d'utiliser le service PubSub « SàT Pubsub », un project fait pour les besoins de Salut à Toi (mais utilisable par tout logiciel XMPP).

un blog sur Libervia

album photo sur Libervia

Cadriciel (framework) web

Le développement de Libervia, le frontal web, l'a mené à devenir un cadriciel (ou « framework ») web. La raison de cette évolution est qu'il fallait une interface très souple, permettant d'implémenter et tester facilement de nouvelles idées ou fonctionnalités. Le but est d'avoir un cadriciel naturellement décentralisé et fédéré (parce que basé sur XMPP), qui s'intègre simplement dans l'écosystème. Je passe rapidement sur les détails techniques, mais il s'agit de lier le moteur de rendu Jinja2 avec SàT et d'utiliser PubSub comme base de données. En outre, le frontal en ligne de commande (jp), permet d'utiliser les même modèles pour faire un rendu statique (par exemple pour générer un blog statique ou des archives d'un salon de discussion).

C'est avec ce cadriciel qu'ont été développées les fonctionnalités mentionnées ci-dessus, elles sont organisées en « pages » qui se veulent simple d'utilisation et peuvent fonctionner sans javascript (quand c'est possible, ce qui n'est pas le cas pour le « chat »). C'est grâce à lui que fonctionne le nouveau site officiel où vous trouverez une documentation d'introduction.

mais encore

Je ne vais pas trop m'étendre, les nouveautés sont trop nombreuses, mais il vaut tout de même la peine de mentionner que SàT peut également être utilisé pour stocker vos fichiers sur le serveur (il peut être utilisé en tant que « composant »), ou que jp, le frontal en ligne de commande permet de gérer beaucoup de choses (retrouver ou publier un article de blog, envoyer un message chiffré ou non, retrouver l'avatar de quelq'un, etc.).


Salut à Toi est disponible dans Debian et ses dérivées, mais attention c'est le cas seulement pour le backend, et les interfaces console et ligne de commandes, de l'aide serait d'ailleurs apprécié pour empaqueter Cagou (interface bureau/appareils mobiles) et Libervia (interface web).

Il est également disponible sur les dépôts AUR d'Arch Linux, et sur cette distribution il existe des paquets pour installer les versions de développement.

Des paquets Flatpak permettent une installation aisée de Cagou, Primitivus (console) et jp (ligne de commande) sur la plupart des distributions GNU/Linux, vous trouverez les liens sur la page principale du site.
Vous pouvez bien sûr aussi utiliser pip, le gestionnaire de paquets de Python. Un simple pip2 install --user sat suivit d'un pip2 install --user cagou voire d'un pip2 install --user libervia devrait suffire. Les instructions sont disponibles dans la documentation du site.

Pour Android, vous trouverez un Apk sur ce lien. Je vais faire les démarche pour le rentre disponible sur F-Droid, et éventuellement le « play store ».

Bien que SàT devrait techniquement fonctionner sur Mac OS X, Windows et les *BSD, il n'est pas testé sur ces plateformes (car je ne les ai pas à disposition). J'ai eu quelques retours sur Mac. Si des personnes sont intéressées, une aide pour tester et empaqueter serait plus que bienvenue.


La principale chose attendue pour la 0.8 est le port sur Python 3, il est enfin possible maintenant que plus aucune dépendance ne bloque, et c'est la seule chose certaine pour la version à venir. Plusieurs grosses pistes sont envisagées ensuite et il va falloir faire des choix, n'hésitez pas à donner votre avis/préférence en commentaire.


Jingle étant déjà implémentée, la visioconférence est prévue de longue date. Elle ne devrait pas être trop difficile à implémenter pour l'interface web (grâce à WebRTC), mais demandera certainement plus de travail sur bureau/Android (évaluer les différentes options, GSTreamer étant le candidat envisagé pour le moment, et intégrer ça à Cagou). C'est un chantier important.

Améliorer le partage de fichiers

SàT propose déjà un partage de fichiers avancé (plus qu'un simple envoi de fichier sur le serveur), incluant un composant serveur. Il est fort possible que des développements continuent dans cette direction.

partager un répertoire avec Cagou

Version iOS

Il serait techniquement possible de porter Cagou sur iPhone. Il y a plusieurs obstacles à cela, notamment juridique (l'Apple store n'est pas compatible avec la licence actuelle, AGPL 3+). IL faudrait également du matériel dédié, et du temps. Ce n'est clairement pas la priorité, mais sachez qu'une version iOS est envisageable.

Passerelle ActivityPub

Avec cette version, SàT peut désormais être utilisé en « composant », c'est-à-dire un service côté serveur. Cette possibilité peut être mise à profit pour créer une passerelle ActivityPub, ce qui permettrait de communiquer dans les 2 sens avec les projets utilisant ce protocole. Il y a déjà un projet en cours de passerelle XMPP pour Prosody, aussi je vais certainement attendre de voir son évolution avant de me lancer moi-même.

Évolution de la messagerie instantanée

Bien que déjà fonctionnelle, la messagerie instantanée peut devenir très complète si on y consacre du temps. Il s'agirait d'ajouter les quelques fonctionnalités manquantes (réactions, correction du dernier message), d'améliorer la gestion des fichiers, des copier-collers des morceaux de code, d'implémenter le chiffrement de bout en bout en groupe, etc. Tout ceci est prévu, la question est de savoir si on en fait la priorité ou pas.

Amélioration de l'utilisabilité

C'est probablement le chantier qui sera prioritaire une fois le port Python 3 effectué. SàT est déjà bien fourni en fonctionnalité, mais les interfaces ont besoin de travail pour être facilement utilisable. J'aimerais en particulier travailler sur le lancement de l'application et la découverte de contacts. Il y a également beaucoup de « petits détails » qui accumulés prennent du temps mais rendent le logiciel beaucoup plus agréable : intégration au bureau, aux actions de partage, une sélection plus agréable des fichiers, etc.

Voilà pour les pistes envisagées, chacune demande du temps et encore une fois vos commentaires/avis sont les bienvenus. Il y a d'autres idées qui traînent, aussi il va falloir bien choisir les priorités.


Salut à Toi est un gros projet qui a un potentiel, mais il est pour le moment développé par une seule personne. Je n'ai qu'un jour par semaine consacré à SàT, et le rythme est très difficile à tenir. Dans les mois qui viennent je vais étudier les options de financement du projet. Il va être nécessaire que je trouve une solution à moyen terme pour que ce projet reste sur les rails.

Liens utiles

  • site officiels:
  • documentation:
  • notes de progression (en anglais):

edhelas 25/07/2019, 06:06


errormovim 07/10/2019, 22:43

SàT progress note 2019-W28

goffi 14/07/2019, 13:21 jabber-xmpp-en SàT project libre SàT progress


remember last week when I was mentioning external things that I've put on hold? There was a Twisted ticket that I've opened months ago, I've made a pull request for that, but there was still some changes to do according to review.

Unfortunately, between my paid job, work on SàT, and real life things I haven't had the time to update it, and little after sending my last week note, I've got an email notification about the ticket being fixed (with a patch replacing mine). I was feeling a bit bad to let this for months and not finding the time to update it myself (in 8 months). Fortunately Twisted folks are nice and understand well ("No need to apologize. We're all volunteers here :)"), and it's a good thing that they managed to fix this issue.

I'm telling this because people don't always understand why things take time (why the release it taking so long? Why nobody did review my merge request?), or may be forgotten. It's just that people can be really really busy, and in free software communities, many of them work on their free time.

During this week, again, it was debugging: really useful for the project, but not so much to tell or explain. The blocker list is getting really low, and I feel fairly optimistic that release can be done next week.

There is maybe one issue I've come through that may worth a mention : while the new chat page of Libervia was working fine during my tests on localhost, it was not working at all once deployed. This is a really simple chat for now, just a proof of concept before adding advanced feature in next version. Libervia pages which come with the new web framework are currently mostly static (i.e. there is no advanced javascript to handle complex changes, this will come in next version), and the chat works by establishing a websocket with the pages, and just sending new messages to display. The web framework is supposed to make life of developer easier, and you only have to declare a dynamic = True variable to activate the websocket. In the background, Libervia create the websocket, associate the page with it, and also the request which is an object containing many useful data, including the session with the profile of the user.

While investigating, I've realised that the issue was happening only in HTTPS, so it was not visible while working on http://localhost. Happily, I'm now working mostly in HTTPS even during local development, this make the detection of this kind of issues easier. I've been using mkcert which makes the process of adding personal certificate painless, and thanks to it I can work easily in HTTPS on my own private and local domain.

This led to an issue with the request object I was storing. This Twisted object is not made to be stored this way, but I was doing it to keep the useful data it contains. Once the HTTP GET request used to retrieve the chat page is finished, the channel is closed, and it is used to test if the request is secure or not (the Twisted session is not stored in the same object or using the same cookie if the request is secured or not). As a result I was getting an empty session, like if the user was not connected, and the chat could not work. I could easily work around this issue, and I've reworked this in a cleaner way; it's working fine now.

The release is not totally ready yet, but I'm already thinking about what's coming next (beside Python 3 port), and there are several big options in my mind, it will be important to choose carefully the priorities. I'll probably focus soon on user experience (UX), as current UI (specially for Cagou), is not that intuitive and accessible for newcomers. I'll write more about this for the release note (which may replace next week progress note).

debacle 15/07/2019, 17:01


errormovim 14/10/2019, 21:06

SàT progress note 2019-W27

goffi 05/07/2019, 10:16 jabber-xmpp-en SàT project libre SàT progress


this week note will be short, first because I've mainly fixed bugs, second because I've pain in my wrist and it's not comfortable to write.

The most visible part of this week work is the addition of some installation instructions on the front page of, which render like this:

capture of installation icons from

(this is a screenshot, this image is not clickage, check to see the real clickable version)

Thanks to the work explained in previous notes, we're getting closer to an easy installation in a few clicks. We're not exactly there yet though, as Flatpak still needs to be installed in most distributions (I think, I don't know exactly where it's installed by default), Libervia (web frontend) is not installed this way (but I'll update the Docker image at some point which is also easy to install/run), and there are maybe other tweaks to do (for instance on Android you must activate the installation from external sources). Please note than when SàT is available natively in the distribution, it's the recommended way to install it.

Also the many ways to install + different frontends/versions (and I've not put yet Libervia + packages for others platforms like Windows or Mac OS) may be confusing. Maybe a platform detection could help to highlight the most probable package in the future.

Another thing which can cause trouble with SàT specific architecture is the backend: for Flatpak I've made a wrapper to launch it automatically if it's not already, otherwise the running backend is used. It works but there is a risk of troubles when the package will be updated and the running backend version may be older than the expected one. I'll have to modify the backend to check that at some point (probably in 0.8).

An other necessary improvement for 0.8 will be the login screen: for now it's really confusing for somebody not used to XMPP (you have to create a profile with a jid and a password, then click on it, then you land to widget selector). I have several ideas on how to change that, but I'll work on it only after release and python 3 port.

That's all for this week note, as I've said in the first paragraph I've mainly done debugging which is not really interesting to explain here. I'm a bit annoyed to lack the time to do more, as I've put aside some external things that I need to finish: I have 2 XEPs to update, and a pull request for Twisted that I've opened months ago and I need to update too. I haven't had much time either to follow standard mailing list, which is a pity because some really interesting things are happening there like the long awaited full stanza encryption.

I hope to be able to fix enough bugs in the incoming week to finally release the 0.7, I'm looking forward for it, and I'm sorry that the release will happen during the summer when many people will be on holidays (well I'm happy for people being on holidays, it's just that it's not the best time to have the release being noticed).


edhelas 05/07/2019, 10:26

SàT progress note 2019-W26

goffi 28/06/2019, 07:28 jabber-xmpp-en SàT project libre SàT progress

Hello everybody,

I was targeting end of June for the release, it seems that I'll have to postpone: it's not ready yet, there are still a couple of annoying bugs. That's a really boring part from a developer point of view, you have to take care of polishing, and things around the code (like the website, documentation or packaging), and you don't see your project evolving much. It's far more exciting to work on new features or experiments, but you need to go through polishing if you want something usable.

I've been talking about Flatpak last week, I still had to do some work on it.

After getting working packages for Cagou, Primitivus and Jp, I've created a repository for that ( and the flatpakref files which are metadata telling where to find and how to install the packages. I was happy to finally have a simple way to install Cagou so people could test it and give feedback, so I've sent a short notice on Diaspora and ActivityPub. I've indeed quickly got feeback reporting the outdated runtime (1.6 while 18.8 is now available, I've just missed it while working with my Manifest from last year), then I had to update the package again.

Once again, feedback has been useful (thanks JBB), so please if you see something buggy or you would like to see something (new feature or anything), let me know!

During my own test I realised that the MIME type for the flatpak refs files was wrong too (it was text/html so the browser was displaying them instead of downloading them). That was a bad default value used in Libervia, and it's now fixed.

After updating the runtime, testing it successfully without installation (using flatpak-builder --run build-dir org.gimp.GIMP.json sat_wrapper) and uploading it, I've had the bad surprise to realise that python2 was missing when trying to run the package normally. It is actually available in the SDK so it was working while testing with flatpak-builder, but not anymore in the runtime (which make sense as Python 2 support will be stopped next year, but still SàT is using it and will move to Python 3 for 0.8 release). So I had to compile Python 2 myself, and make several try to make it work correctly (and that's only after it worked that I have discovered that there was a pre-made module offered by Flatpak teams).

All of that to get this thing:

Cagou flatpak package seen on KDE Discover

Integration in the package manager (here Discover from KDE) is nice to have, and I hope that it will be the case by default in most distributions in some time. I'll propose the package on Flathub (the central repository of Flatpak) once the stable release is out.

There are still some little issues on the package/metadata (like the screenshot which are not at the recommended 16:9 format), but I'll take care of them later, I have already spent enough time there and I need to move forward. Furthermore, the screenshots seem to be displayed correctly beside their format on KDE Discover and GNOME Software.

Far more serious, there are some crashes on the Flatpak version of Cagou (I've had a infinite recursion crash when clicking on bookmarks) that I don't have on normal packages, so I have to debug that but that's part of the general debugging phase I'm now in.

To install dev preview packages of Cagou, Primitivus or Jp from Flatpak, just enter the following commands:

  • flatpak install --user
  • flatpak install --user
  • flatpak install --user

And later to update them:

  • flatpak update

Or use your graphical software manager. I'll add the links to the website soon, so it should be installable in a few clicks.

Remember that it's dev version, so expect bugs, and in addition there are still some issues specific to the Flatpak version that I'll try to fix today.

That's really a lot of time spent on those packages, but I now have scripts which will help to updates everything easily. Imagine if I had to do all packages myself for every GNU/Linux distributions + Docker + Flatpak + AppImage + Snap + YunoHost + Android + *BSD + Windows + Mac OS + … . I'm already doing several on this list, but I can't do everything alone, so if you feel you can help on packaging, please contact me (see address at the bottom of or join us in our official room at or via web). Note that there are already people working on Arch packages and on Debian and derivatives (but they need help).

So now it's all about debugging and documentation until the release.


edhelas 28/06/2019, 07:29

SàT progress note 2019-W25

goffi 20/06/2019, 15:58 jabber-xmpp-en SàT project libre SàT progress

Hello everybody, time for a new progress note.

This week I've been working with Flatpak. Flatpak is a new way to package applications using containerization, which has pros and cons: for a low overhead the applications can be run on most GNU/Linux distributions, they run in the same reproducible environment, and they have limited access to outside. I prefer using software packaged in my distribution when they're available (better integration, no overhead at all), but Flatpak is a nice way to try quickly something or to have access to software not packaged in our distribution.

About SàT, the main goal is to have super simple installation so people can try Cagou (desktop/mobile interface) easily. I'm also working on packages for other frontends mainly jp (CLI) and Primitivus (TUI), so they can be tested quickly. I hope this can encourage people to try them, and help gain some visibility.

Let's talk technical now. I have already worked on Flatpak nearly 1 year ago, and could launch several frontends using hand made manifests (the files instructing Flatpak how to build your application). I didn't found the time to polish it and it has never been made public.

This time, I wanted to have something as automated as possible: there are several frontends, and dependencies may change, I don't want to have to do everything by hand each time I update the packages.

The main difficulty when building flatpak, is that you have to deal with what is available in the "runtime" (the base of the distribution you'll use), and without network (you can't make internet connection during building process). In the case of Python, that means that you have to download every dependencies (including their own dependencies, etc.) and then install them in the right order (if you have wrong order, a module installation will fail because of missing dependency). This task is more complicated that it seems.

Flatpak ecosystem propose a script to make this task easier: Flatpak PIP Generator. It retrieves dependencies of a Python package, download them, generate the hash and retrieve download URL to prepare a list of "modules" usable in the manifest. The problem is that the list is not ordered according to dependencies, and the JSON produced is not directly usable. I quickly moved to make my own script specially tailored for SàT needs.

The first issue with dependencies is that there is no good way to find them. They are normally declared in the script which is the standard way to install a Python package, but you can't import this script to analyze it (it would execute its code and the usual if __name__ == '__main__' way to avoid that is never used with

Well you have PyPI doing the analyze for you, and if you use its JSON API you can retrieve the mandatory requirements + optional ones using the ['info']['requires_dist'] field of the metadata object. Except that this field is far from always being complete, for instance it's not set for Twisted (I have not investigated for the reasons, maybe because Twisted is using an other file dynamically read). Twisted is far from being the only package without this data, so it's unusable in my case.

I've searched a bit on Internet and made different tries, and at the end the best I've found to reliably get the dependencies used by a Python project is to install it in a virtual environment and to parse the output of pip show <package_name>.
This command output a text with a Requires: line showing the actual requirements used in this project. Thanks to that I could solve the dependencies hell problem and my script is able to order correctly and automatically the modules needed in my manifest. The only modules not managed are setup requirements (requirements needed only for building the modules), but there are only a few of them and it's easy to specify them by hand.

I'm actually doing it in two times: first I download (using pip download) the requirements of the Python package to get the list and version needed, then I install the package in a virtual environment to analyze the output of pip show (pip handle a cache, so packages are not downloaded twice).

So my manifest generation script which I was expecting to do quickly took actually most of my free time this week and it's still not finished. I'm adding other options and I have to faces troubles likes Mercurial not being managed by Flatpak (for this case I have to retrieve myself the repository and upload it manually). I'm also sparing you other troubles (like how to organize the packages, SàT being a specific architecture I've first made my own runtime before being discouraged of doing this on the Flatpak mailing list).

At the end it's a lot of time spent just to make installation easier, and I have to do everything myself. I hope this kind of stories I'm explaining in my notes helps people to understand why it takes so long to develop a software, specially when you're on your free time. I hope also this work will help to popularize the project, and, maybe, bring some helping hands :)

See you soon.

SàT progress note 2019-W24

goffi 13/06/2019, 07:07 jabber-xmpp-en SàT project libre SàT progress

As mentioned in my note 2 weeks ago, I was in holidays and skipped last week note.
It has been a really good thing, a relief, to be out of the screen for a couple of days, I recommend!

So I'm now back to work in my paid job, and working again on SàT on my free time. We are already in the middle of June, and the release is still not done; it's time for the home straight. As you can see if you follow progress notes, I'm working regularly, and moving forward each week, but there is so much to do. Anyway things are getting better now, the new website is online with documentation, the tickets system is working even if still buggy (it's getting better with time), and I start to have feedbacks, meaning that people are testing.

During my holidays I've got a report on ActivityPub about an issue with <link> elements, followed by a bug report. With those informations, I could spot the issue and fix it (it was a problem with caching, the data used in template were not deeply copied, and the list containing links was reused and growing each time the page was accessed). Thanks to Rydroid for reporting the issue.

When you test and see something wrong, the right thing to do is to contact me, and if possible report a bug on If it's easier for you, you can contact me by other means, but the ticket creation is the better way to be sure it's not forgotten.

I've finished and deployed the pubsub experimental option I have talked about in a previous note. I've called it consistent publisher and the goal is to keep original publisher if a node owner or an admin modify an item. The main reason is to maintain permission to edit the ticket for the original publisher, and thanks to that I can now change status of a ticket without replacing publisher.

Overwriting an item is not yet ideal in pubsub: either you follow XEP-0060 and any publisher can overwrite any other publisher item (not great in case of tickets or blog comments), or you restrict overwriting to your own published items but you need to do a workaround like this. I have ideas on how to improve the situation with node options and I'll probably propose a XEP at some point after SàT release.

As you know, I'm focusing on debugging, and I've spotted a couple of annoying bugs that I'll fix in the incoming week. My target is a release before the end of June. I have started work on packaging Cagou for desktop with Flatpak, so it should be easy to install and test on most GNU/Linux distributions, I'll probably talk about that in next week note.


edhelas 13/06/2019, 07:07

debacle 14/06/2019, 12:03

SàT progress note 2019-W22

goffi 31/05/2019, 15:06 jabber-xmpp-en SàT project libre SàT progress

Hello everybody,

during this week I've put online the new official website at

This is an important step for several reasons, let me explain.

The former site (which is currently still available at, not sure yet how long it will stay here, but it won't be maintained anymore) was made with Django + bootstrap. It was working and not so bad, but outdated (with a really old screenshot on the front page), and it was a pain to maintain it in parallel of the work on SàT
Django is great, powerful, with a big community, but using it only for our presentation website means that we have to follow its evolution, and we have to solve issues from time to time, e.g. when we update the version. Django template engine is similar to Jinja2 that we use, but it's different enough to have to check documentation to maintain it, not a big deal, but some work that we could avoid.

By moving the website to our own Libervia framework, we stay on the exact same stack as SàT itself, so we don't have to follow other frameworks/libraries, it's easier to maintain. Also it's a good use case to test the framework, and make it evolve according to real life use case.
Furthermore, it simplifies our life for some features, like the news available at, which is an XMPP blog. With Django we were using a iframe displaying a Libervia instance, while now we can directly show the blog.

With the new website I have added a "documentation" section. So far the documentation was mostly on the wiki, but it was not well maintained and a bit messy. Now it's inside the project itself, and written using reStructuredText which is the markup used most of time with Python project. Also we use Sphinx to render it nicely. As a result, we have a better rendered documentation, which is closer to the project (we can even use source code itself and its docstrings) so it should be up-to-date, and we can use the same source to produce things like man pages or a PDF manual.
Having to render the documentation with Sphinx, was the main reason to create our task manager in Libervia Web Framework.

The documentation is far from being complete, but I'm working on it. You can already see how to use jp for blogging or sending end-to-end encrypted message.

Now the TODO list for the release is done. What is left is debugging, writing documentation and packaging… And some rest! I'm currently in holidays so there will probably not be any progress note next week.

debacle 11/06/2019, 07:36

nik 12/06/2019, 07:18

Side note: You can simply switch Django to Jinja2 with one setting.

goffi 13/06/2019, 06:21

Nik: indeed, but I would still have had to convert existing templates, and keep up-to-date with Django evolutions.

SàT progress note 2019-W21

goffi 24/05/2019, 07:45 jabber-xmpp-en SàT libre project SàT progress


this week has seen a bit of work on the website (mostly porting pages from the older one), and again the time to work on the project was short.

When your work on your free time, any moment you take for yourself (a week-end outside, reading a book/newspaper, watching a movie, having a drink, doing sport, etc.), or for the "things which must be done" (cleaning house, administrative things, fixing stuffs, etc.), or simply when you are sick, is time lost for the project, and it goes quickly. I'm living in such spirit for more than 10 years, feeling remorse for everything taking time, and it's not healthy or even sane, not for your nor your loved ones. And even in your project itself, there are a lot of stuff you have do to around it (server administration, website, documentation, communication – like progress notes –, keeping up to date with technologies, etc.) which are not directly improving the software.

I'm explaining this for you, the reader, to understand why it takes so long to develop a project, and why it can get on nerves. You can see now with the progress notes, that the release is nearly ready but still I've had little time to fix issues, and I wont be able to have everything perfectly oiled for this release.

Last week I've mentioned Pubsub, so let's move to this topic.

I won't elaborate on Pubsub itself, just for short Publish/Subscribe is a way to store/get data and to be notified when there are changes. You can see my talk at last FOSDEM (mp4 version) for some use cases. It is notably used in XMPP for blogging, i.e. for the "social network" part of it, and in SàT for events, tickets, merge requests, forums, etc.

During implementation of blogging features in SàT, years ago, the Pubsub implementations in XMPP servers were uneven, and mostly incomplete (because it was not needed for chat which most of the clients were focusing on). There was two options to work around that: choose a server with a working implementation, focus on it and recommend it, that's what have done Jappix and Movim with Metronome, or create a server agnostic component. We have chosen the latter with SàT, and have created "SàT Pubsub", a server independent implementation of PEP/Pubsub, which aims to be the most complete possible.

I've had to write and propose 2 XEPs (XEP-0355 and XEP-0356) to make this possible, but I'll pass the details to avoid making this post too long. Also, this would have hardly be possible without the work of Ralph Meijer which made the base Pubsub implementation in its library Wokkel that we use in top of Twisted, and Idavoll that SàT Pubsub derivate from.

So we now have an independent Pubsub implementation where we can implement everything we need without having to wait for every server to follow some new XEP. And even today when XMPP servers implementations have improved a lot, SàT Pubsub has some unique features, can follow novelties quickly, and is a good place for experimentation. I don't think all server implementations can be on a par with that, at least in the close future.

With that background explained, I'll now explain what I've worked on this week. In standard Pubsub (XEP-0060) when you have the suitable right, you can publish an item (a blog post for instance) with an existing id, this will create a new item and delete the one which was existing previously. But if we have a node where many people can publish, like a blog comment node, that means that anybody can replace the comment of anybody. So if Louise has written something, Pierre can replace the comment, not great.

In some pubsub implementations, which is the case for SàT Pubsub, you can't overwrite an item if you are not the publisher of this item, except if you are admin or owner of the node. That's better regarding blog comments, but there is still an issue: if Louise is owner of a node, and overwrite an item of Pierre, to modify something, she become the new publisher of the item, and Pierre can't modify it anymore. This is notably a problem with tickets: if Pierre report a bug, and Louise changes its status (e.g. because she starts working on the ticket), she becomes the new publisher, and Pierre can't edit it anymore).

To work around that, I've added a new node option which can be activated in configuration, "consistent publisher", which will keep the original publisher even if the item is overwritten (updated) if the entity overwriting the item is owner or admin. I've also prepared an option in database to restrict the maximum number of items in a node, but it's not implemented yet. I can now safely change status of reported issues for SàT without loosing initial publishers.

This week the post was longer than usual, I'll try to keep it shorter next time. As usual, feedbacks are welcome.


edhelas 25/05/2019, 08:24

SàT progress note 2019-W20

goffi 17/05/2019, 10:01 jabber-xmpp-en SàT project libre SàT progress

Little progress during this week, I've had a busy week-end far from computer (and it's a relief from time to time to be freed from screen).

I'm working mainly on the new website, so I'll explain a bit why doing a new website.

When you have a project, the website is the place people go to know what it is, and SàT is a quite difficult project to explain because it's doing a lot of things, and people get lost easily with it. We are now using the term "communication ecosystem" to explain it, as it seems to fit well: a generic tool for most of your communication needs (chat, file sharing, blog, events, etc.).

We have done current website a while ago using Django, which is one of the most popular web framework on Python (and even outside Python). Django is a great piece of software and has a huge community, but working on the official website with it means that we have to learn, maintain and follow extra technologies. Note that I'm using "we" because we are several people at the association, but I'm currently the only active developer and any extra amount of work is hard to take.

On the other hand, 0.7 version of SàT brings a web framework, based on the ecosystem and so on XMPP. That has many advantage: notably there is nothing new to learn and follow, and it's a concrete use case which allow to test and improve the ecosystem.
Furthermore, the XMPP integration allows to integrate effortlessly things like the official blog, while in the former version we had to include a page of Libervia in a <iframe>.

To summarize, moving the official website on Libervia web framework make the task more easy and is an occasion to test and improve the whole ecosystem.

One of the things that has been improved in the last few months is the integration of a task system, i.e. a way to launch piece of code on certain conditions (in particular if some files are changed), something similar to what you would have with Grunt, for instance, in Javascript world.
This is used to generate SàT documentation, using Sphinx to create HTML page from reStructuredText: when Libervia is launched with --dev-mode, each time the doc is modified, the HTML pages are rebuilt, really handy to check quickly that the syntax gives what you're expecting.

The new official website will be simple, with only a small page of presentation of the software, the documentation, social contract, and few extra pages. Most of it is done, and now I'm porting some pages from Django (the template system is similar to Jinja2 that we use, but it still needs adaptations, and the CSS classes are not the same).

During this, I'm also fixing bugs when I see them or somebody reports them. For instance, I've fixed this week a bug with registration on If you test any part of the ecosystem (being it desktop or mobile with Cagou, web with Libervia, TUI with Primitivus or CLI with jp), please give feedback either on our chat room (web), or via the SàT/XMPP based ticket system at

I was going to explain some changes I need to do on SàT Pubsub but this post is already long enough, I guess I'll keep it for next week (wow, teasing!).


edhelas 17/05/2019, 11:00