The Retroshare project is supported by Freifunk, which Google has granted to be an umbrella organisation for Google Summer of Code this year.
If you’re a student who fulfills the conditions to be funded by google (See here), and if you have good C++ skills and would love to work in a challenging environment that involves networking, cryptography, distributed resources and multi-thread computing, then you’re eligible to get paid for coding in the Retroshare project during 3 months: May to July.
How to proceed
You would like to participate in one of the subjects below? You have a great idea that is not listed? You want to talk to the developers to see if some idea you have fits the project goals?
- read the requirements of GSoC. It would be a shame to figure out, once your application is ready, that you cannot apply for any administrative reason;
- contact the Retroshare developers. We’ll find a way to connect you to the appropriate chat rooms to discuss your ideas.
The student application period starts on March 20, 2017. However, it is very important that you spend some time digging into Retroshare’s code, talking with the devs, and defining what you’re going to do before that, since applications are sorted by merit, motivation of the student, and likelyhood to succeed. Supplying a sparse google application form will most likely not let you in.
Suggestions of subjects
These are just suggestions. As said above, you can come up with your own, provided that it fits the goals of the project. Most of the text below is copy-pasted from Freifunk ideas page (which we filled ourselves anyway).
Some of these subjects rely on the GXS distribution system (stands for Generic eXchange System). It is currently not documented, but a technical paper is currently being written about it and will be available during spring.
Wall/blog plugin based on GXS
Retroshare contains a generic distributed database system (called GXS) which allows to share data between nodes, in a way that is cryptographically secured (database access may be limited to circles of people, etc). This database system is currently used for distributing forums and channels over the network. The GXS system also offers the possibility to respond, submit comments, and vote over posts. We would like to use it to create a service that allows users to create a blog-like service, to which friend nodes subscribe so as to propagate the info over the network. Depending on the student’s skills and motivation, such a plugin could offer one of the following similar services: twitter (distributed micro-blogging), blog (distributed blogging), Wall (facebook style information sharing).
Things to be implemented:
- plugin interface to the backend. Needs to properly define how to represent objects (posts, responses, comments) by which GXS components.
- GUI for the Wall/Twitter/Blog service (preferably Qt. Could be Json+web, but would add some complexity)
- backend service, based on GXS interaction handles
This is not an easy project, since GXS internals are hard to understand in the first place. But the devs are highly motivated to get it done.
A calendar/task GXS-based plugin
This the typical plugin that one would like to have when using Retroshare in a professional environment. The work consists in first representing the various calendar/tasks objects into GXS components. Then it needs to implement the calendar GXS service which will serve as an interface between the GXS distribution system and the UI. Finally it needs to implement a minimal Qt UI to display and manage calendar events. Optionally, to provide an API in a standard calendar format, so that people can use their own UI/client software to display the events.
The service will manage publishing/creation rights over the calendar events, and use GXS to sync the data between participants.
This project needs a good knowledge of Qt, since a lot of UI will be needed. Alternatively, a more complicated option is to benefit from the existing JSon API to make this plugin a WebUI component.
The software already has a preliminary web interface, but it covers only the very basics of the software interactions, and does not benefit from the nice graphical look it should have. This project is probably the easiest of all, since the software already implements a partial JSon API to join the software internals and the html requests from the browser, but it still represent a lot of work as the software currently offers a lot of GUI handles in its Qt version that would need to find an equivalent functionality in the web interface version.
By order of priority:
- improve the web UI for file transfers (it is extremely basic now), adding/removing friends, showing internal statistics, etc.
- implement the web UI for configuration options
- implement a nice looking CSS for the web UI
Most of user-input texts in the Retroshare software are supplied to the backend as HTML by Qt. Although it offers a lot of possibilities, it is also a double weakness both in terms of security and CPU-efficiency. The plan is therefore to implement a markup language (ex. a subset of AsciiDoc) translation which would ensure that a only minimal set of features can be represented and displayed (namely emoticons, links, images, font-style–bold, italic…).
This project will require to:
- Define a new text editing widget/component that has the needed buttons and options to handle markup text (e.g. link and image insertion). Similar to the one used in RS-Mail.
The widget should:
- Accept markup text to be displayed and convert it internally into proper HTML that Qt will understand
- Allow the user to get the markup text generated by the widget.
- Possibly ensure some minimal backward compatibility with the existing data.
Video over IP in RS
Retroshare offers the possibility to talk using Voice/Video over IP, but only as a toy system. It currently needs a skilled developer to integrate a proper cross-platform video codec that would be capable of frame-rate auto-adjustment and be robust to network delays. This is a challenging project that needs a good understanding of how VoIP works and interacts with the network layer.
Things to be implemented:
- find a suitable cross-plaform video codec. Take inspiration from Mumble, Matrix, etc.
- handle auto-adjustment of bandwidth for video/sound with proper priority handling to avoid gaps
- proper GUI device selection and notifications
- [optionally] implement 3-parties conferencing
Chess/Go plugin – play between GXS identities
Retroshare v0.6 offers an authenticated/encrypted/robust tunnel system to exchange data in real time between pseudo-anonymous identities over the network. This system is already used for chatting, but it has a lot of potential. At the same time Retroshare offers a plugin system that users can leverage to create new decentralised services. The Retroshare Chess/Go project has a double tap impact: creating a simple example of a portable service plugin using the new tunnel system of v0.6, and creating a cool game interface to allow users to play Chess/Go. This project includes some GUI (which will be done in Qt) for the games, and a bit of backend to handle the interface with the tunnel system. It also needs to fit in the current plugin architecture which will be adapted if needed.
Things to be implemented:
- game data exchange service and encrypted tunnel handling
- GUI for the games
- GUI for game handling
We intend to provide this plugin as an example to allow people to develop their own plugins.
Retroshare 0.6.x offers interesting community primitives based on cryptography such as pseudo-anonymous identities, reputation handling and circles of friends, but it still lack IPv6 support that is a fundamental to complete the appeal with community networks.
The student should implement IPv6 support in RetroShare low level networking code in, and extend higher layer parts to support multiple kind of addressing. That probably means re-writing parts of the network addressing layer which needs an additional level of abstraction.
This is a challenging project, but quite essential for the future of the software.
Community networks are about freedom and decentralization, RetroShare brings principle that motivates community networks to application layer, and it is very suitable for use in our community networks because it take advantage of the decentralized nature of the network, still our physical infrastructure doesn’t cover the whole world, and lot of people around the world suffer censorship and severe limitations to freedom of speech and communication. Implementing censorship avoidance in RetroShare we could bring some more communication freedom to people that live far from a community network while expanding our physical networks to reach them, the idea is about disguise the RetroShare traffic as HTTP (when necessary) that is usually not blocked/filtered and can cross also restrictive proxy. This include RetroShare binding on some “carriage free” ports like 80 (where user give it permission), and encapsulating RetroShare traffic as HTTP requests with some long polling strategy, imitating transfer of normal HTML pages with images etc etc. The idea can evolve as firewall get more strict implementing some more steganography painlessly, this would be an innovative technique for a P2P network and make posing serious cost effectiveness threats to a potential censor.
Having support for adding friends through WebUI would be nice.