xpra icon
Bug tracker and wiki

This bug tracker and wiki are being discontinued
please use https://github.com/Xpra-org/xpra instead.

Version 1 (modified by Antoine Martin, 7 years ago) (diff)

archive the old page

Project Ideas

Xpra is a remote desktop tool providing many exciting features as compared to other open source tools. It is developed with a mix of Python and C, and works on many platforms. The list below describes Google Summer of Code project ideas, aimed both at improving Xpra and at teaching the students about how a remote desktop solution works.

Xpra is taking part in Google Summer of Code 2014 under the umbrella of the X.org organization. Students will therefore be applying to X.org GSoC after having discussed their project with Xpra. To apply, you need to :

  • download, build and use Xpra a little
  • join the IRC channel
  • read the existing documentation to get the best possible understanding of what Xpra is (you will be quizzed on the matter)
  • contribute at least one patch to the project, that is subsequently committed to the repository
  • discuss a project idea with the developers, in order to build your own understanding and goals for this project
  • write the project proposal including several milestones with deliverables and an approximate timeline

1) Xorg related improvements: RandR, DPI, DRI3K

Xpra acts as an X11 compositor, and uses many different X APIs and features to achieve its purpose. We have run into some limitations related to X11 features. For example, Xpra has to be able to dynamically adapt the remote (server-side) virtual framebuffer to match the client configuration exactly. Although this mostly works OK using xf86-video-dummy and libfakeXinerama (to fake the same number of screens), there is still much room for improvement.

  • Better RandR support in the dummy driver (xf86-video-dummy) to allow us to use any resolution we choose without needing to have it pre-defined in the xorg.conf shipped with xpra. The changes may actually need to be applied to the core server and/or the dummy driver.
  • DPI issues (should probably be tied to the RandR issue above - though it may also interact with libfakeXinerama): some applications will talk to the X11 server directly to obtain the screen dimensions and calculate their own DPI value. The virtual screen we define for Xpra is not meant to have a fixed "physical" size: it is meant to adapt to what the client specifies and should be changed whenever a new client connects. Because the X11 server assumes that the dummy screen size is fixed, the DPI values calculated by the client applications will vary widely depending on the current screen resolution set at the time the DPI is calculated, causing some ugly rendering problems. The dummy driver needs to support changes to the "physical" screen dimension at runtime (and not just the resolution). Note: this is now mostly solved in #163
  • DRI3K support. Someone interested in the world of X.org may be interested in this project.

Difficulty: hard
Keywords: C, X11, X.org

2) Wayland

With the advent of Wayland, a modern replacement to X11, the basis of Xpra (the X Composite extension) disappears. Xpra is conceptually an X compositor, and it could be modified to also become a Wayland compositor. This project is about making Xpra Wayland-compatible so that Wayland gets a network "transparency" layer that is efficient with fully open source (aside from the existing Wayland RDP implementation). Tasks are :

  • Understand Wayland and its concepts ("surfaces", input devices, etc)
  • Make Xpra behave (optionally and in addition to X11) as a Wayland compositor
  • Promote the work towards the Wayland community, and submit it for review

Difficulty: medium/easy
Keywords: Wayland, compositor, X.org, X11, network transparency

3) Keyboard mapping improvements

The applications running on the server need to receive mouse and keyboard input. It is easy to map the client-side mouse-input to mouse events on the server side, but it's more difficult for the keyboard, because the keyboard mapping on the client side can be different from one client to another (US, french, german, ...). What transits over the wires are keycodes (the physical position of the key on the keyboard), and they are translated back to keysyms (the keymap-dependant symbol produced when the key is pressed) on the server side. Xpra uses obsolete X APIs to do this translation work, and often gets it wrong. In addition, running virtual machines with e.g. VirtualBox inside Xpra adds another layer of keyboard translation, and the end result is often wrong.
The tasks for this project are:

  • Learn and understand the X11 keyboard input system (specifically Xkb)
  • Re-implement keyboard mapping logic using Xkb instead of core keyboard API (probably using the xkbcommon library)

Difficulty: hard
Keywords: Xkb, X11, input, C

Non-Xorg related project ideas:

4) Automated problem reports

The Xpra client, like any piece of software, has bugs. It sometimes crashes. It's not a big deal: you just have to restart the client, and you'll get your applications back (unless the server crashed also, but it happens less often). However, whenever it crashes, and especially on Win32 platforms, there is very little information that can be sent to the developers to help them fix the bug, and reproducing the crash is not always straightforward.
This project is about making Xpra easier to debug. Ideas are :

  • Integrate an automated stack trace mechanism
  • Generate automatic crash reports, including screenshots if necessary, to enable easy bug reporting for users
  • Allow building of the client with debug symbols

Difficulty: medium
Keywords: Python, backtrace, automated bug reporting

5) Android client support

The objective is for Xpra to support as many platforms as possible for the client. An Android client exists but is not completely up-to-date in terms of feature, and its usability is far from perfect. This project consists in improving Android client support, or, alternatively, implement Xpra client support for another mobile platform (be it Linux - Raspberry Pi, Android, or any other OS).
The tasks for Android consist in the following:

  • Support keyboard
  • Support pinch to zoom
  • Support video scaling
  • Add any required feature for comfortable, seamless remote desktop

The applicant is encouraged to propose implementing support for any other low-power/mobile platform, with an extensive list of tasks to be carried out and prior technical research.

Difficulty: Hard
Keywords: Android

6) Latency improvements through hardware-accelerated video decoding

Remote desktop software is very sensitive to latency. Too high of a latency can kill the user experience. Latency sources are obviously the network, but also and usually more importantly, the video encoding on the server side, the video decoding on the client side, and the video presentation on the client side.
We have preliminary support for OpenGL presentation on the client side (doing YUV to RGB conversion and drawing), which helps with latency. However, there is the technical possibility of offloading the video decoding process to the GPU using such APIs as VAAPI (Linux) or DxVA (Windows), possibly both through libva which we already use. This project is about improving latency of Xpra, with the following tasks :

  • Offload video decoding to the GPU through libva
  • Make this work on Windows clients as well as Linux clients
  • Make this work with OpenGL presentation on the client-side
  • Do whatever else is necessary to improve latency

Difficulty: medium
Keywords: OpenGL, libav, video decoding, Windows, Linux, Python, C

7) Encryption

At the moment, Xpra can use AES encrypted communication over TCP. It supports password authentication, but the key exchange system is open to MITM attacks.
Xpra supports a mode where it connects through an SSH connection. That mode is good, but doesn't answer all needs: it requires an ssh server and each user connecting to the session to have shell access on the system, no matter what application needs to be run.
The objective of this project is to implement a secure transport mechanism, based on known good cryptographic algorithms.
Tasks are:

  • Implement secure key exchange
  • Implement correct AES CBC mode
  • Assess performance impact in terms of latency, bandwidth, and CPU requirements

Difficulty: Medium, knowledge of good crypto practices
Keywords: (py)crypto, AES

8) Win32 server (shadow mode)

Xpra's client works on many platforms, but the server is restricted to Linux. This means that Xpra can only be used to remotely access a Linux-based desktop. It would be very interesting to make Xpra's server able to work on a Windows machine. Currently there is preliminary support for this feature but it uses polling which is very inefficient.
This project is about improving support for Windows-based server, so that it achieves satisfying performance. Tasks would include:

  • Implement screen update detection code so xpra can forward only the parts of the screen that have actually changed (as it does on *nix)
  • Implement win32 socket code so "xpra info" can be used on win32 servers
  • Rely on benchmarks to assess which improvements to make and

Applicants are required to have some Windows development experience.

Difficulty: Medium
Keywords: Windows named pipes, GDI