Click to reduce…
I have been working for a while on an XMPP client with a daemon/frontends architecture: the idea is that you have the main logic centralised in the daemon side, and you can make very different lightweight frontends for the view. The project is intended to be a modular, multi-platform, multi-frontend communication software. The frontends can be adapted to a particular use case, or platform.
Currently, there are a desktop frontend, a console frontend, a command-line frontend, and a web frontend. A Kde frontend is also planned.
The project is quite difficult to summarise, as it touch a lot of domains (it's not intended to be only an instant messaging software, but to explore deeply the power of XMPP): with it you have instant messaging, e-mail style heavy messaging, multi-user chat, microblogging, file sharing, games, etc.
Salut à Toi (SàT) - which means « Hi to you » - is heavily based on the Twisted framework, and the XMPP library Wokkel, which is on top of it and should be integrated in Twisted in the future. The core backend concentrate only on the RFC, a couple of XEP, and the essential stuff to run. Most of the XEP and the advanced functionalities are put in plugins, that allow the code to be modular, and to choose which features you want (you can remove plugins to suppress features for e.g. a public station). SàT manage several profiles: you can use different profiles for different accounts on different servers.
The backend communicate with the frontends throught a "bridge", which is actually an IPC: so far, D-Bus is used, but it is possible to use an other one. All the frontends and the backend together make one client, that means that if you enter something in one frontend, it will appear in the other ones like if it was enterred there. It also means that the history of the conversations is shared, and that if you create one profile somewhere, it will be created globally.
As the backend is independent of the frontends, you can use SàT without graphical interface (i.d. without X running), or unplug a frontend while the backend is still running (e.g. to terminate a long file transfert).
As you can guess by seeing Twisted, SàT is made with Python, it is actually 100% Python, including browser side code (see below); but an other language can be used to make a frontend. Actually any language able to talk with D-Bus can work, and the planned Kde frontend will be made with C++.
Wix: the desktop frontend
Wix is the reference frontend, it is used to test implementation of features. It is based on wxPython. It's intended to be a classical desktop frontend, which should work everywhere. In the future, it could be change its interface for a more experimental one.
Primitivus: the console interface
Primitivus is for console lovers. It is based on Urwid, and the interface is more worked. I had to make several widgets for this frontend, so I eventually put them in a separated library: urwid-satext (Urwid's SàT extensions), I hope they can be usefull for other projects.
JP: the command-line tool
JP is a swiss knife, it can be used in many ways. It can be use to easily send file: I spend most of my time in a shell, and it's often annoying to have to go in thousand dialogue boxes just to send a file, furthermore if I am already in the good directory. With jp, I can just type:
jp file firstname.lastname@example.org
and I plan to use a more friendly interface like "jp file nickname".
In addition, jp can send a whole directory by compressing it, accept multiple files without having to accept each time, or send the output of an unix command. It can be used as a powerfull scripting tool, e.g. to notify you when something happen on your server.
In the future, it should gain lot of features like sending microblogs, or managing roster.
Libervia: the web frontend
I have waited to make this frontend to start the communication about SàT. Libervia is close to what the fashion wants to name "social network", but with a big emphasis on privacy and user respect; it clearly wants to be an alternative to the massively centralised commercial services. It's entirely made in Python, thanks to pyjamas, with is a Python port of GWT.
There are many thing to say about pyjamas: group centred right management, clear interface, use of widgets, unique input box, visual indicator to show who will be able to read your message, etc.
All of this is shown in a video (in French, but I'm pretty sure it's understandable without the sound, any help to make subtitles welcome):
This video is under Creative Common BY-SA
In addition, a technical demo is online: http://www.libervia.org . Please don't pay any attention to the ugly appearance, we are working on it and it should be really nice looking soon.
Libervia, as the whole SàT project in linked to a social contract, see below.
Some things you can do with SàT
Here are some stuff you can do with SàT:
- Use your e-mail client (MUA) to read and send your messages: XMPP manage "normal" type message, which are heavy messages pretty similar to e-mails (with a subject and a body). This messages are often managed really basically by XMPP clients, but this job could be done by feature-full stable and well-known e-mail softwares like KMail, Thunderbird, Mutt, Roundcube, etc. So, 3 extensions have been made: one to manage a Maildir box, one to manage an IMAP server, and one to manage a SMTP server. Theses extensions allow to connect most of e-mails clients to SàT, and use them to send message to your XMPP contacts, receive messages from them, or even send message to standard e-mail network throught an SMTP gateway. I think XMPP is an excellent candidate to be used as an alternative to e-mail.
- Microblogging: SàT manage microblogs (only in Libervia so far), not only in the popular classical public way, but also with access restriction through roster-based group access. For example, if you have all you family members in the group "family", you just have to enter "@family: Salut à toi la famille" in the input box, and only the member of your family will be able to read this message. If you want to publish this for everybody, just enter a double @, like this: "@@: my global public message". With this, not only all you contacts will be able to read your message, but even people you don't know as it is public (on the online demo, you can see them through http://www.libervia.org/blog/your_nick).
- receive multiple files from one contact without having to individually accept them: jp, the command-line tool, allow (among other things) to automatically accepts files, or to send a full directory at once by making a tarball with it.*
- Nothing to do with XMPP, but an extensions allow to send message to a Couchsurfing account. There is a way to make lightweight XML interfaces for plugins: that allow to make a plugin which will work with all frontends; the couchsurfing plugin was just an excuse to try it.
- Play French Tarot: I have made a French Tarot game (a card game extremely popular in France), which is playable on the desktop with Wix, in text-mode with Primitivus, or in a browser with Libervia. It was a test in the idea to make a general card game XEP, any people interested in cards games for XMPP can contact me.
Games are an important part of SàT. The following stuff are planned:
- Generic card games engine: the Tarot Game was an implementation test of a card game. I'd like to take profit of this experience to make a generic XEP, wouldn't it be nice to play your favourite card game through your favourite XMPP client with your friends ? If you are too far to play on a real table of course :)
- I'd like to do the same think for board games, and a Xiangqi game is planned (Chinese chess)
- A quiz game is planned in the very short term, probably for next release
- on the long term, everything can be made, even maybe real-time games
Maybe the most important point of all the project: a social contract has been made, and show the principles that SàT and people involved in it follow. It can be read here: http://www.libervia.org/contrat_social.html, but it's only available in French so far.
- The SàT backend, Wix, Primitivus and jp are under GPL v3+
- urwid-satex is under LGPL v3+
- Libervia in under AGPL v3+
What's next ?
I have reached the point I wanted to build the foundations of the project, and make it credible. Now I need to stabilise everything, clean and re-factor several parts of the code, remove all the ugly Q&D hacks, finish half-made things, etc.
It's the perfect time to give a hand :)
But new features are planned on the short time, mainly picture sharing and quizz game.
You want to help ?
All the tools needed for contributions is here (wiki, bug tracker, mailing list, mercurial repository).
The project use many really interesting stuff like Twisted, Wokkel, Urwid, Pyjamas, etc. It can be a good way to discover them and improve you skill, and I hope give them some contributions.
The help I need:
- developers ! The project begin to be too big for me alone. In particular, I need people to port SàT on other architectures (*BSD, Android, Mac OS X, Windows, etc.). Only portable technologies have been used, so it should ask a reasonable amount of work.
- tester: SàT should work with most browsers, most platforms, most XMPP server, etc.
- Graphic designers: many things to do: icons, design, etc. Somebody just started to help me on this point, that means that the aspect should improve quickly.
- CSS designers, Libervia should offer different kind of presentations
- donations: if the project succeed, would you make some donation ? Should I take some time to have a donation system ?
If you are interested, the first thing is to subscribe the mailing list: http://lists.goffi.org . I hope to have around 10 peoples to start to use it seriously.
This post is only an overview of Salut à Toi, and I think the potential is very big. I strongly believe in the community, and I hope I have interested you enough to have a hand :)
I finish with two videos showing the project (the third one is linked above), but they are in French. Any help to make subtitle for them welcome.
This video is under Creative Common BY-SA
This video is under Creative Common BY-SA