GSoC 2015 logo

See also: GSoc Instructions, Last year ideas

Guidelines

Information for Students

These ideas were contributed by our developers and users. They are sometimes vague or incomplete. If you wish to submit a proposal based on these ideas, you may wish to contact the developers and find out more about the particular suggestion you're looking at.

Being accepted as a Google Summer of Code student is quite competitive. Accepted students typically have thoroughly researched the technologies of their proposed project and have been in frequent contact with potential mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.

When writing your proposal or asking for help from the general KDE community don't assume people are familiar with the ideas here. KDE is really big!

If there is no specific contact given you can ask questions on the general KDE development list [email protected] See the KDE mailing lists page for information on available mailing lists and how to subscribe.

Adding a Proposal

Note Follow the template of other proposals!





Project:

Brief explanation:

Expected results:

Knowledge Prerequisite:

Mentor:

When adding an idea to this section, please try to include the following data:

if the application is not widely known, a description of what it does and where its code lives

a brief explanation

the expected results

pre-requisites for working on your project

if applicable, links to more information or discussions

mailing list or IRC channel for your application/library/module

your name and email address for contact (if you're willing to be a mentor)

If you are not a developer but have a good idea for a proposal, get in contact with relevant developers first.





Ideas

Your Own Idea

Project: Something that you're totally excited about

Brief explanation: Do you have an awesome idea you want to work on with KDE but that is not among the ideas below? That's cool. We love that! But please do us a favor: Get in touch with a mentor early on and make sure your project is realistic and within the scope of KDE. That will spare you and us a lot of frustration.

Expected results: Something you and KDE loves

Knowledge Prerequisite: Probably C++ and Qt but depends on your project

Mentor: Try to see who in KDE is interested in what you want to work on and approach them. If you are unsure you can always ask in #kde-soc on Freenode IRC.

Plasma

Project: Port various KDE4 Plasmoids to Plasma 5

Brief explanation: When we ported from Plasma 4 to Plasma 5 some useful Plasmoids ended up not being initially ported. We want the more important existing applets to continue to run which . Students should select a few Plasmoids which they deem useful for their proposal along with some innovative ideas for improvements. Students should show knowledge of the level of work related.

Expected results: A few fully working plasmoids, polished and better than before.

Knowledge Prerequisite: QML skills. Ideally some Plasmoid experience

Mentor: Sebastian Kugler with help of the Plasma team.

Project: Port KSystemLog to use journald as a backend

Brief explanation: KSystemLog is a tool for viewing log files. This has slowly started to fail as log files moved in various distributions. Journald provides a common interface to query programatically system and user logs which will fix the main issue. Applications should impress me with their ideas utilising the available features.

Expected results: A ported to frameworks journald powered log viewer.

Knowledge Prerequisite: C++, Qt.

Mentor: David Edmundson with help of the Plasma team.

Project: Port various Systemsettings KCMs to QML

Brief explanation: The codebase of the systemsettings modules is old and needs a redesign both code-wise and UI-wise. Students should select a few KCMs and propose how to port them to the new QML/C++ hybrid with some ideas on the improvement of their UI.

Expected results: A few fully working KCM modules ported to a mix of QML and C++ that still load correctly in Systemsettings and KCMshell.

Knowledge Prerequisite: QML and C++ skills.

Mentor: Marco Martin with help of the Plasma team.

Various Places

Project: package install for 3rd party applications

Brief explanation: KDE software needs to install software in various places. Investigate the best way to do this which is probably to use packagekit. Then implement this in the places which need it.

Expected results: Work out best way for 3rd party programs to query and install packages. Then adapt the following pieces of software to install the packages they need:

dolphin file share install samba

kcm access to install orca

gwenview to install kipi-plugins

kcm locale should install kde-l10n-xx

kickoff to implement package install like kicker?

k3b needs to install codecs (on ubuntu at least)

all this should be done in a way which works for the major distributions.

Appstream could be used to find package names to install although support for this in Ubuntu is incomplete.

Knowledge Prerequisite: C++

Mentor: Jonathan Riddell (Riddell in #plasma on freenode IRC) with help of the Plasma team.

Plasma and Gluon

Project: Extend gamingFreedom.org framework to be more generic

Brief explanation: Over the last couple of years, the gamingFreedom.org website and server side components have been created, which implement Open Collaboration Services (OCS) in a generic and reusable form. We are now at a point where it would make sense to attempt to use this for further purposes, rather than only for gamingFreedom.org. Specifically, a new implementation of the server component employed for hosting Plasma related content is needed, and a website for presenting this content on the web.

Expected results: A new website based on gamingFreedom.org's OCS client libraries, and a server implementation for hosting Plasma content.

Knowledge Prerequisite: PHP for the client and server code

Mentor: Claudio Desideri and Dan Leinir Turthra Jensen with help of the Plasma team.

Kdenlive

Kdenlive is an intuitive and powerful multi-track video editor, including most recent video technologies. Our software is completely free, as defined by the GNU foundation. Using Kdenlive is investing in a community driven project, which aims to establish relationships between people in order to built the best video tools.

Project: Add support for new Animation capabilities

Brief explanation: MLT, the media frameworks we use for rendering, has recently added a new property animation to its objects. This allows much simpler, smoother and more general animations than the traditional keyframes technology. We then need new widgets to edit these properties, and eventually evolve our on-monitor interactions.

Expected results: At the end of the project, we should be able to add and graphically adjust these animation parameters through controls in the effects stack panel, and bonus on the monitor.

Knowledge Prerequisite: In the end you will assemble QtWidgets and interact with MLT data through C++. So you should be at ease with C++ and Qt (no need to be an expert), and have a look to the MLT manual page about animation.

Mentor: Vincent Pinon with help of the Kdenlive team.

Project: Redesign titler using WebVFX

Brief explanation: Our titler, the tool we use to add text and drawing objects over the video, relies on a home made module added to the MLT framework. Our module is limited in features, quite slow to render, and demands work to maintain. MLT has since then been plugged into WebVFX engine, which provides infinite possibilities through web technologies, and it is certainly more robust. The goal is then to port our titler to this engine, then maybe evolve the interface to offer new possibilities.

Expected results: At the end of the project, the titler should rely only on MLT WebVFX module. Bonus we should be able to add and easily edit more objects types.

Knowledge Prerequisite: First step is to translate our XML to Web formats inside the C++ code, so you should understand those dialects. For the UI rework, you would then work with Qt, in either C++ or QML.

Mentor: Vincent Pinon with help of the Kdenlive team.

Project: add import/export filters for video editors exchange formats

Brief explanation: To reduce the barrier to switch to Kdenlive, users should be able to import and export with commercial editing softwares (at least partially). Some scripts already exist to crudely parse EDL or AAF formats, the goal is to do it cleanly integrated in Kdenlive.

Expected results: At the end of the project, we should be able to exchange projects with one or more commercial tools. Effects and transitions will probably be limited, but timeline construction should be transferable.

Knowledge Prerequisite: The work will consist in manipulating XML data with Qt (C++), so you should understand those dialects.

Mentor: Vincent Pinon with help of the Kdenlive team.

Project: make Kdenlive work on Windows and OSX

Brief explanation: All the frameworks Kdenlive relies on are working on other platforms, and Kdenlive used run on those long time ago. The goal here is to setup build environments on one or two other OS's, and fix the things that prevent Kdenlive to work.

Expected results: At the end of the project, Kdenlive should work reliably on one or two commercial OS's.

Knowledge Prerequisite: Setting up and running builds, fixing things in C++, CMake, dependencies.

Mentor: Vincent Pinon with help of the Kdenlive and KDE porting teams.

Amarok

Amarok is a Music player that helps you organize and rediscover your music.

Project: Port Amarok to Qt5/Kf5/Plasma5

Brief explanation: Currently Amarok still depends on kdelibs 4.x and Qt4.

Expected results: Amarok should compile with Qt 5.x, kdelibs4 dependencies should be replaced with kf5. Port most existing plasma widgets of the Context View to Plasma 5 (at least the most important should be ported). The default system themes should apply to Amarok flawlessly. A very important part of this project is testing the port and adapting the unit tests.

Knowledge Prerequisite: good knowledge of C++/Qt, ideally being familiar with kf 5 and Plasma 5. The student should have some basic knowledge of the Amarok project and its functions as well as its architecture. All relevant information about Amarok, Qt5, kf5 and Plasma 5 can be found online, every suitable applicant should be able to find this documentation on their own.

Mentor: To be determined. All discussions about the project should be held on the mailinglist and/or on IRC

digiKam

digiKam is an advanced digital photo management application for Linux, Windows, and Mac-OSX.

Project: Re-write database KIO-slaves as pure Qt5 using multithreading

Brief explanation: Originally, KIO-Slaves have been implemented to run database queries in a separated process to prevent problem with SQlite. Since SQlite support re-entrancy and queries from separated threads, digiKam KIO-slaves used to process complex and long database queries can be re-written as core implementation using Qt thread API. This will improve digiKam availability in time when system is updated in low-level, and permit to adjust finely CPU cores assigned to database process.

Dependencies: : digiKam core from "framework" branch (KF5)

Links: Using Sqlite in multi-threaded application, Bug #146557

Knowledge Prerequisite: C/C++, Qt, database, multi-threading

Expected results: Identify all parts of digiKam core which query database through KIO-slaves mechanism, factorize code in same interface and write a multi-threaded wrapper to run SQlite queries. Write test code to check quickly if database core implementation changes don't affect wrapper functionality. Note : digiKam use internally URL + XML formating to pass data to KIO-slaves and this not be changed.

Difficulty: high

Lead Mentor: Gilles Caulier <caulier dot gilles at gmail dot com>

Project: Advanced Metadata HUB

Brief explanation: digiKam has already some options to manage workflow between image metadata and database, through the setup/metadata configuration panel. The goal of this project is to write a more advance setup to control finely the most important metadata field in order to read from image and populate database and vis versa. The list of metadata to drive must be easily extensible and configurable. Also, the metadata workflow to synchronize image with database must be more flexible and must provide a way to synchronize files at end of digiKam session and not only in real time (typical case : editing image tags to write in images).

Dependencies: : digiKam core and libkexiv2 from "framework" branch (KF5)

Links: Bugs list from bugzilla

Knowledge Prerequisite: C/C++, Qt, database, multi-threading

Expected results: Create metadata hub widget for settings panel, adjust current hub and image scanner implementations, add test code.

Difficulty: high

Lead Mentor: Gilles Caulier <caulier dot gilles at gmail dot com>

Project: Add WebP and WebM support

Brief explanation: WebP/WebM is new wavelets based image/video format from Google, based on RIFF/MKV container. This format become more popular on the Web and both can be used through an open-source library. We need to support these formats as editable in digiKam (WebP) and manageable by database mechanism through metadata (WebP and WebM).

Dependencies: : digiKam core and libkexiv2 from "framework" branch (KF5), Exiv2 library

Links: WebM format, WebP format

Knowledge Prerequisite: C/C++, Qt, Metadata

Expected results: Patch Exiv2 library to support both formats in read/write meta-data mode and add optional WebP support in digiKam core to be able to edit images (read/write image contents in 16 bits color depth). Write test code to check new functionality in time.

Difficulty: high

Further Informations: GSoC/digikam/WebP_WebM_wazery_proposal

Mentors: Gilles Caulier <caulier dot gilles at gmail dot com> + Someone from Exiv2 team

Brief explanation: All tools dedicated to import or export items from KIPI host applications to web services as Flickr, GDrive, Dropbox, Facebook, Picasa, etc... need to be factored and ported to KF5/Qt5. Factorization include to make common widgets (settings, GUI layout, rules, etc), and background processing to prevents duplicate code. Also, in order to reduce KIPI host application time loading, the number of tools must be limited. Tools must be grouped by categories, as Social Networks, Cloud Service, Photo Hosting, etc...

Dependencies: : digiKam KIPI interface, KIPI Plugins

Bugzilla entries: 221704

Knowledge Prerequisite: C/C++, Qt/KDE, GUI

Expected results: KIPI web services tools ported to KF5 and running with digiKam 5.0.0.

Difficulty: high

Lead Mentor: Gilles Caulier <caulier dot gilles at gmail dot com>

Marble

Marble is a virtual globe and world atlas — your swiss army knife for maps. Find your way and explore the world!

Project: Starting to edit OpenStreetMap Data

Brief explanation: During the last Google Summer of Code 2014 Cruceru Calin worked on an Edit mode for Marble. Right now it's possible to draw elementary shapes and features (Polygons/Polylines, Placemarks, GroundOverlays, etc.). These geometry primitives can be saved as KML files and there is some experimental OSM support already. This project will be about extending the current Edit Maps mode. Focus will be especially towards enabling advanced editing that allows for more sophisticated drawing capabilities but also for tagging and other features that are required for OSM support. A special focus might also be on refactoring the existing code base where it's useful.



Expected results: Reliable and useful means to create and edit OSM files using Marble.

Knowledge Prerequisite: C++, Qt,

Mentors: Torsten Rahn, Cruceru Calin, Dennis Nienhüser

Project: Improve Printing Support and polish Marble rendering

Brief explanation: Marble has good rendering and basic printing of a screenshot already in place. However we'd like to see high resolution printing. This project should explore ways to improve printing support (e.g. by resizing the widget temporarily to a big geometry and printing the resized canvas). In order to adapt to the higher resolution the text size and the line widths need to adapt automatically to the increased resolution. As a result of this project Marble should feature largely improved printing of the current scenery (including the current map theme and projection) that is visible to the Marble user. As a second part of this project regular Marble rendering should be improved. This would include:

* Improved rendering of Placemark Labels * Improved rendering of Street labels (e.g. in OSM rendering) * Improved OSM rendering * Improved rendering of the OSM tiles to reduce bluriness during reprojection.

Depending on the skill-set of the student and depending on project progress code-refactoring of the Marble rendering in order to prepare for OpenGL support could be included with the project as well.

Expected results: Improved printing support with high resolution maps. Better rendering of Placemark/Street labels and better rendering of OSM textures.

Knowledge Prerequisite: C++, Qt,

Mentors: Torsten Rahn, Cruceru Calin, Dennis Nienhüser

Project: Turning Marble into a small GIS system

Brief explanation: During the last Google Summer of Code 2014 Cruceru Calin worked on an Edit mode ("Annotation Plugin") for Marble. Right now it's possible to draw elementary shapes and features (Polygons/Polylines, Placemarks, GroundOverlays, etc.). These geometry primitives can be saved as KML files. During this project we'd like to extend the feature set towards classical requirements of a GIS system. Focus will be especially towards enabling advanced editing that allows for more sophisticated drawing capabilities but also for tagging and other features that are required for a GIS Editor. Depending on the experience of the student we might also focus on other topics like Data analysis or PostGIS support.

Expected results: Adding capabilities to Marble that allow for using it for simple tasks that people would usually do using Quantum-GIS.

Knowledge Prerequisite: C++, Qt

Mentors: Torsten Rahn, Cruceru Calin, Dennis Nienhüser

Project: Statistical Data Visualization and Extending Marble Game

Brief explanation: During the last Google Summer of Code 2014 Abhinav Gangwar created the "Marble Game". This project is about extending Marble's library in a way so that it's easy to display statistical data on maps in a color coded ("choropleth") way

The Marble application should include a default dataset that allows to display such maps for a set of important properties per country (e.g. life expectancy, literacy, etc.). A browser for statistical data should be added to Marble. The CIA Factbook data should be updated as well as the placemark data. The Marble Game should be further improved and it should be possible to make use of the Statistics feature.

Possible additional tasks: Add streetview feature to Marble and the Marble Game.

Expected results: Marble provides a tool that allows to visualize a ready-made dataset of statistical data in a color-coded choropleth way. The Marble Game should also be extended to make use of that feature.

Knowledge Prerequisite: C++, Qt

Mentors: Torsten Rahn, Abhinav Gangwar, Dennis Nienhüser

KStars

KStars is a very powerful tool for anyone interested in astronomy. It is part of the KDE Edu suite.

Project: Ekos Scheduler

Brief explanation: Ekos is an advanced astrophotography tool for Linux. It utilizes INDI for device control. With Ekos, the user can use the telescope, CCD, and other equipment to perform Astrophotography tasks. However, the user has to be present to configure the options and to command the actions to perform all the astrophotography related tasks, and hence a scheduler is required to automate observations to be constrained within certain limitations such as required minimum angular separation from the moon, whether conditions...etc. Furthermore, the observations should be triggered when certain conditions are met such as observation time, object's altitude...etc. The prospective student is expected to develop a Simple Ekos scheduler to trigger observation runs when certain conditions are met and when the limitations are required.

Expected results: Simple scheduler to automate astrophotography runs based on some conditions and within user-configurable limitations.

Knowledge Prerequisite: C++, Qt, INDI

Mentors: Jasem Mutlaq (IRC: knro)

The student will need to:

Look at the relevant code, and propose a tractable plan for implementing some of the improvements within the GSoC timeframe.

Implement some of the improvements, producing production-ready code that can be included in the next release of KStars after GSoC 2015.

Project: Constellation art

Brief explanation: KStars currently draws constellation lines, names, and boundaries, but constellation art is missing. The student is expected to study KStars API and develop a new SkyComponent to superimpose the constellation artwork unto the sky map while re-working other components in KStars to support this. The structure must support multiple sky cultures. The artwork itself must be available under a permissible license. New constellation artwork should be available for download using the KNewStuff framework. The user should be able to select the sky culture.

Expected results: High quality artwork for Western constellations in addition to one non-western constellation artwork that can be switched on/off in the sky map.

Knowledge Prerequisite: C++, Qt

Mentors: Jasem Mutlaq (IRC: knro)

The student will need to:

Look at the relevant code, and propose a tractable plan for implementing some of the improvements within the GSoC timeframe.

Implement some of the improvements, producing production-ready code that can be included in the next release of KStars after GSoC 2015.

Project: Fix our deep-sky data handling

Brief explanation: Currently, KStars handles data from deep-sky object catalogues in an SQLite database. While this is working well, there are some more features we would like to have, and some that should be implemented in order to sanitize the deep-sky data handling, such as automatic cross-referencing of deep-sky objects across catalogs, organizing deep-sky data better in the database etc using Hierarchical Triangular Mesh, etc.

More details here: http://techbase.kde.org/Projects/Edu/KStars/Better_deep-sky_handling

Expected results: Some, or all of the improvements to deep-sky handling suggested above (or maybe even your own suggestions), implemented completely in solid, release-worthy code.

Knowledge Prerequisite: C++, Qt, understanding of astronomical catalogues, some experience with data structures.

Mentors: Rafal Kulaga (IRC: rkulaga)

The student will need to:

Look at the relevant code, and propose a tractable plan for implementing some of the improvements within the GSoC timeframe.

Implement some of the improvements, producing production-ready code that can be included in the next release of KStars after GSoC 2015.

PS: If all this looks daunting, that's because you have not (yet) talked to us. If you're really interested, get onto #kde-kstars and ping the mentors.

Project: Propose your own project

Brief explanation: If you have some interesting ideas about KStars that can be implemented within the GSoC timeframe, you are very welcome to propose them, because we seem to have run out of ideas.

Mentors: Rafal Kulaga (IRC: rkulaga)

KDE Edu

Project: Integrate Cantor into LabPlot

LabPlot is a KDE-application for interactive graphing and analysis of scientific data.

Brief explanation: The integration is twofold:

currently, for the created plots LabPlot uses either the data provided by hand in a spreadseet or by using data imported from external ascii-files. By having Cantor within LabPlot it should be possible to access the data sets created in a computer algebra session (say Maxima) provided by Cantor. Cantor's session have to be integrated into LabPlot's model-view framework and have to be put onto the same foot as all the other objects managable in LabPlot (spreadsheet, worksheets etc.). By calling a CAS-specific command for creating a 2D-plot in Cantor, Cantor creates an external process that renders the plot and embeds the result as a pixmap. Instead of such a static pixmap, LabPlot's plots should be embeded. This would provide high degree of control of the plot appearance as provided by LabPlot.

Mentor: Alexander Semke

Project: Integrate VTK into LabPlot, investigate Tulip

LabPlot is a KDE-application for interactive graphing and analysis of scientific data.

Brief explanation:

LabPlot lacks 3D-functionality. In the old KDE3-based LabPlot qwt3D was used for this that is not an option anymore. The task consists of the integration of VTK -libs. Also, the relevant widgets for 3D-plot editting should be created in a manner similar for all the other objects available in LabPlot now. Investigate whether it's reasonable to use LabPlot as a frontend (or to extend it to be a frontend) to the functionality provided by Tulip yes, how?

Mentor: Alexander Semke

Project: Port of GCompris in Qt Quick

GCompris is a an educational software suite comprising of numerous activities for children aged 2 to 10. Originaly written in Gtk+ it's development team decided to rewrite it from scratch in Qt Quick. It has also been decided that this version will be integrated in KDE which is the reason of the project being here.

Goals:

Porting several GCompris activities in Qt Quick. There is a page that tracks the porting effort that will help you select the activity set you are interested in. Creating new activities. There is a list of ideas of activities that have been identified as something we would like to have. You can also propose original ideas not on the list.

Knowledge Prerequisite: By the start of GSoC you should

Be interested in children education Be familiar with GCompris concept and content Basic knowledge in a programming language (a 1 year school course is enough) Be able to build the Qt Quick version of GCompris

Application guide:

Writing or porting an activity takes about the same time. The advantage of the porting is that the tuning, the graphishm and the sounds are already available. You can count 2 weeks of development for an activity. To keep the work interesting it is recommended to propose a mix of porting some activities and creating new one, either from the idea list or from an original idea you come with. You have to follow the instructions here and provide your exercise as a pull request.

Mentor: Bruno Coudoin (IRC: bdoin #gcompris on freenode)

Project: Make an Editor Library/Plugin for KVTML Files

Kvtml is a file format for vocabulary training that is used by all of the language applications in KDE Edu. The format is loaded into a KEduVocDocument class which is handled by a library with the same name. The format is reasonably rich with a tree structure for lessons and support for sound, images and any number of translations.

To edit the KEduVocDocument many applications implement an editor. Some editors, like the one in Parley, are quite advanced with support for the whole format, as well as semi-automatic translations from websites like wiktionary.com and google search for images. Others are much simpler like the one in KWordQuiz, which is more or less only a simple table editor.



Goals:

The goal of the project is to separate the built-in editor in Parley into a library and/or plugin and make it available for other applications. This editor library should be made flexible and configurable so that applications with different needs could create an editor which supports the level of sophistication that suits that application best.

Summary of the goals:

Separate the editor of Parley into a library. This library could either be placed into the current existing libkeduvocdocument repository or be placed into a library of its own. Remove all existing ties to other parts of Parley and generalize the settings to APIs. Make the editor more flexible and configurable so that the application can create its own level of sophistication of its editor. Note that this configurability is intended for the application programmer, not the end user of the application. Improve the documentation by providing a tutorial for the application programmer and also complete API documentation. Make Parley use this editor library instead of its current built-in one.

Knowledge Prerequisite: By the start of GSoC you should

be familiar with the kde edu language applications in general and Parley in particular be familiar with the kvtml format and the KEduVocDocument library. be familiar with C++ and Qt be familiar with building and running KDE applications

Mentor: Inge wallin (IRC: ingwa #kde-edu on freenode)

Keyboard Layouts

Keyboard layouts in KDE allow user to use multiple keyboard layouts and switch between them. It consists of keyboard configuration module (in System Settings), keyboard layout widget/applet, and keyboard layout daemon.

Project: Integrating Input Methods with keyboard layout configuration

Brief explanation: Input method and keyboard layout configuration are serving the same purpose - to allow users to type text in non-default language. Currently KDE has integrated system to configure keyboard layouts but IM need to be configured somewhere else. Also when IM is configured it takes over some functions of keyboard layout configuration. So it would be nice if we could have IM and keyboard layout configuration in one place. It seems that IBus has already gained community acceptance so this will be the target for integration into KDE keyboard module.

Expected results: Keyboard configuration module in System settings will include IM configuration and it will be integrated with existing keyboard layout options.

Knowledge Prerequisite: good knowledge of C++, development experience with Qt and KDE, understanding of Input Methods (IBus)

KDevelop

Project: Clang Integration

Brief explanation: Finish the kdev-clang plugin to make it a usable replacement for the existing C++ plugin.

Expected results: Find the still missing features from the KDevelop4's C++ support and port them over to kdev-clang, so it can become the mainstream C/C++ Solution

Knowledge Prerequisite: C++, Qt. Knowledge about Clang is helpful

Mentor: Kevin Funk

Project: Checker Framework

Brief explanation: A generic framework should be created which provides the foundation for other plugins to report errors.

Expected results: Right now we have the problems toolview but it is tightly coupled to the DUChain. This should be changed to use a separate item repository which stores the problems for a given path. The data stored would be: Path and range of where the issue is found, a short error message and optionally a long description. Furthermore, plugins might want to store additional info from which the problem could be fixed (compare to the 'add include path' or similar wizards we have already in the language framework).

This framework should then be used to integrate various tools.

First of all the existing language plugins should show the problems they find there. The existing playground plugins for krazy and cppcheck integration should reuse that framework any other linters could be integrated, such as jslint, pylint, clang-check, etc. pp. runtime checkers could be integrated, such as valgrind's memcheck, ptrcheck, helgrind, drd, ...

Knowledge Prerequisite: C++, Qt. Knowledge of debugging tools is helpful.

Mentor: Milian Wolff

Project: SVN Plugin Rewrite

Brief explanation: Rewrite the SVN plugin to use the C-API directly.

Expected results: The existing SVN plugin uses an outdated kdevsvncpp checkout internally which causes troubles, warnings and licensing issues. Port the plugin to either the C-API of svn or alternatively try to reuse code from current kdevsvn. The result should be a tested, working plugin for SVN integration without licensing issues nor compile time warnings about usage of deprecated API.

Knowledge Prerequisite: C, C++, Qt, SVN

Mentor: Milian Wolff

Project: LLDB Support

Brief explanation: Write a new plugin to support LLDB on KDevelop

Expected results: Come up with a new kdevelop plugin so that LLDB can be used as a debugging solution, especially on Mac OS X and Windows, where gdb support is rather scarce.

Knowledge Prerequisite: C, C++, Qt, debugging intrinsic problems

Mentor: KDevelop team

KDE PIM

The KDE PIM community work on a set of libraries and applications for Personal Information Management, including email, calendaring, contacts, and feed aggregation.

Project: OpenHolidays

Brief explanation: The KHolidays library provides KDE applications with information on public holidays around the world, however the file format is very hard to use and maintain and the library features are very limited and restricted to Qt users. The goal of the OpenHolidays project is to develop a new open standard and data repository that can be used by any project that needs the data. See http://community.kde.org/KDE_PIM/KHolidays for more details.

Expected results: Define the new JSON file format and port the existing data files to the new format. Develop a shared Qt-only library to parse the holiday files and provide access to them with a iCal style event-based api. Implement an Akonadi resource to access the data. Extended goals: Develop a JavaScript library to use the files. Develop a web site and web service at openholidays.org to provide online access to the data files.

Knowledge Prerequisite: C++ and Qt for core goals, JavaScript and web services for extended goals.

Mentor: John Layt and other KDE PIM community members.

Project: QtQuick ToDo API / Plasmoid

Brief explanation: KDE PIM wants to make it's data accessible for applications which use QML to declare their user interfaces, e.g. applications using QtQuick. For that they need data handling objects that are accessible through QML, e.g. item models that have a mapping of string based role names to enum value based roles in C++, etc.

Expected results: Define and implement a general QML API for accessing and creating Akonadis ToDo data. Write / Port a ToDo Plasmoid for Plasma Desktop or Plasma Active to show off the new API. Bonus: Port Kontact Touch Task to the new API instead of, or in addition to the Plasmoid.

Knowledge Prerequisite: C++, Qt, QtQuick

Possible Mentors: Kevin Krammer, and other KDE PIM community members

Simon

Simon is a speech recognition suite.

Website - Mailing list - IRC channel: #kde-speech on Freenode.

Project: Streamline handling of various resources

Brief explanation: Simon uses a multitude of different components: Scenarios, Base models, Shadow vocabulary, Language profiles, etc.

While many of these components can be downloaded from within Simon, some can't and even for those that are better integrated, end-users still have to read additional documentation to know which components work together and which don't.

The aim of this project is to bring the handling of these resources under a uniform and user-friendly interface. Specifically, the interface should resolve conflicts automatically and deduce an optimal default setup by itself (e.g. based on the system language and installed programs).

Expected results: Much more user friendly setup.

Knowledge Prerequisite: C++/Qt

Mentor: Peter Grasch <peter {+at+} grasch.net>

Resources: Some work (mostly brainstorming and UI design) was already conducted during Season of KDE 2013. Please contact me for details. This does not mean that this project is already assigned!

Okular

Okular is a Document Viewer.

Project: Better Accessibility for Okular

Brief explanation: We should implement Qt accessibility APIs to make Okular usable by more users. This would allow blind people to read documents.

Expected results: You should be able to "read" Okular documents using Orca or other "screen reading" software. As long as the document exposes the contents in text form, we can let assistive technology pick it up and present it to the user in a different way (for example non-textual). An important goal is to transfer as much of the structure of the document as possible, so that ideally the sematics (this is a heading, here is normal text, page number) are preserved. Finding well working PDF solutions is still a challenge for blind people on any operating system. For now the focus will be on Orca since it's the best working screen reader on Linux used by most blind users.

Knowledge Prerequisite: C++

Mentor: Albert, Frederik helping out with the accessibility parts

Project: Implement PDF Poppler features

Brief explanation: Poppler has some support for features we don't support, implement them

Expected results: Poppler has support for pdf layer views, tagged pdf support, linearized pdf support yet we in Okular don't offer that features to our users. The result from this project is having those exposed to the final users

Knowledge Prerequisite: C++

Mentor: Albert

Project: Implement SecurityHandler V6 in Poppler

Brief explanation: Poppler needs to support SecurityHandler V6 to be able to open some pdf files

Expected results: Poppler (and hence Okular) can open files with SecurityHandler V6 like the ones in https://bugs.freedesktop.org/show_bug.cgi?id=85368 and https://bugs.freedesktop.org/show_bug.cgi?id=88151

Knowledge Prerequisite: C++

Mentor: Albert

KDE Connect

Project: Improve KDE Connect encryption

Brief explanation: We want to implement a better encrypted protocol for KDE Connect, as discussed here: http://albertvaka.wordpress.com/2013/09/19/how-kde-connect-encryption-works/ I would like to see a solid and peer-reviewed design before accepting this project.

Expected results: Have a secure encryption algorithm implemented in both KDE (C++/Qt) and Android (Java) clients.

Knowledge Prerequisite: Deep knowledge about encryption and security.

Mentor: Albert Vaca <albertvaka {+at+} gmail.com>

Resources: kdeconnect

Project: Build a Qt-only multiplatform KDEConnect client

Brief explanation: We want to implement a cross platform client written in Qt that can run in virtually any platform supported by Qt (Windows Phone, Jolla, iOS, OSX, etc.) using the QPA (Qt Platform Abstraction) and QML. It will be challenging because Qt5 for phones is still quite new and implementing some features might not be possible yet, but it will be worth it to investigate what is possible and what not, and even contribute patches to Qt for some aspects. A lot of the core classes used in KDE Connect for Plasma could be reused and shared because they are mostly Qt (and would be part of the GSOC to make sure they end only using Qt, so we can get to re-use them). Not every feature is going to be available to every platform, and some plugins will be platform-specific, but as part of this GSOC project I would love to see it running as good as possible in one of the platforms already mentioned, and with basic functionallity in a couple more. (That is: center it around a platform and make it work well there, writting platform-specific plugins and code if needed, but making sure it still compiles and runs in other platforms).

Knowledge Prerequisite: Qt5 and building cross-platform code.

Mentor: Albert Vaca <albertvaka {+at+} gmail.com>

Resources: kdeconnect

Solid

Project: Improve sharing experience

Brief explanation: Improve the content sharing experience in Plasma by extending and improving Samba share, implementing other ways of sharing and write new ways of discovering other people's shares.

Expected results: It should be possible to discover "shares" using dolphin (possibly via a new kioslave?) and it should be possible to share a folder between two Plasma computers really fast and easy (possibly implementing an http server plus discovery via avahi).

Knowledge Prerequisite: C++/Qt, extra points for KIO experience.

Mentor: Àlex Fiestas <afiestas {+at+} kde.org>

Resources: avahi, http, kdenetwork-fileshare

Muon

Project: Better support for your distribution

Brief explanation: Muon needs to be ensured to work perfectly on any distribution, this project should target one of the (major) distributions, enumerate the problems to solve and propose solutions.

Expected results: Muon users of your distribution will be happy ever-after.

Knowledge Prerequisite: C++/Qt, the technology required for the platform

Mentor: Aleix Pol





KWin

Project: DRM/KMS backend for kwin_wayland

Brief explanation: KWin_wayland currently only supports rendering to another Wayland server. In future it should be possible to go down to the hardware directly. For this a DRM/KMS rendering backend is required. This requires that a new backend is implemented for the OpenGL compositor and maybe the QPainter compositor. As KWin needs to handle kernel mode settings in this mode the output information need to be queried from the hardware and an implementation for KWin::Screens needs to be provided and from there propagated to the Wayland clients. In addition if the time of the project permits it an interface should be exposed for KScreen to configure the outputs.

Expected results: KWin_wayland can render to DRM/KMS and fetches output information from the hardware

Knowledge Prerequisite: C++/Qt, Wayland, KMS and C knowlege are from advantage

Mentor: Martin Gräßlin <[email protected]>

Trojitá

Trojitá is a fast IMAP e-mail client. Since late 2012, it is a part of KDE's extragear. The project focuses on delivering a usable, fast, standards-compliant, cross-platform and reliable e-mail client which can scale from cell phones to huge e-mail archives without annoying slowdowns.

Project: Port to BlackBerry OS 10

Brief explanation: This work involves improving the separation of business logic from the UI concerns, an effort started and well-underway due to the Ubuntu Touch project, and adding a new GUI wirrten in QML for BlackBerry OS 10.

Expected results: Trojitá running on BlackBerry Z10 with basic features, including reading and writing e-mails

Knowledge Prerequisite: C++/Qt, QML

Mentor: Jan Kundrát <[email protected]>

Project: Multiaccount support

Brief explanation: Trojitá's GUI only shows one IMAP account at once. The scope of this task is to analyze what needs to be done, and implement the required changes for making it possible to show multiple IMAP accounts. General bugfixes are expected in the rest of the time.

Expected results: Full support for multiple IMAP accounts, including unit test coverage

Knowledge Prerequisite: C++, Qt

Mentor: Jan Kundrát <[email protected]>

Gluon

Gluon is a project to build a Qt and KDE based game engine and game development tool. The engine is designed to support both mobile and desktop game development. We have ported the engine to Qt5 last year and are currently working on releasing a first Qt5 based version.

Project: Build a QtQml based script system

Brief explanation: In Qt4 QtScript was the solution to scripting support for applications. With the port to Qt5 the new QtQml module was introduced, including a new scripting system, but QtScript was still available. With Qt5.5 QtScript is planned to be deprecated and completely removed in Qt5.6. This means that our scripting system, which is currently built on QtScript, needs to be ported to QtQml.

Expected results: A scripting system that can be used to write scripts for games.

Knowledge Prerequisite: C++/Qt at least. Experience with QtQuick/QML is a strong advantage.

Mentor: Arjen Hiemstra

Project: Expand Gluon Input

Brief explanation: During the port to Qt5 we also overhauled the input system in Gluon to be more capable. However, we kept the implementation rather limited since we also had other elements to work on. This project would expand GluonInput with support for additional devices and platforms.

Expected results: Additional platform and device plugins for GluonInput.

Knowledge Prerequisite: C++/Qt at least. Experience with platform-specific input libraries like XInput2 for Xorg is an advantage.

Mentor: Arjen Hiemstra

Krita

Krita is an advanced 2D painting application. It support creating images from scratch from begin to end. Krita is a complex application and developers need to have a fair amount of experience in order to be able to do something.

Project: Integrate Animation in Krita's core

Brief explanation: We have gone through three iterations of animation support code in Krita. With this experience, it's become clear that we need to work the support for animatins right into Krita's core engine. This project comprises partly that, and partly updating the existing animation gui that was created in 2014.

Expected results: by the end of the summer, the animation support in Krita should be ready for end-users to create 2D animations with, whether for game sprites or short cartoons.

Knowledge Prerequisite: C++/Qt at least.

Mentor: Boudewijn Rempt

Project: Add Python Scripting to Krita

Brief explanation: Krita has had two attempts at scripting support: through kjs and through kross. Neither was good enough. The VFXindustry standard for scripting is Python, and the goal of project is to integrate Python and PyQt directly into Krita.

Expected results: by the end of the summer, users should be able to automate repetitive tasks, file import and export and add gui elements such as dockers, all written in PyQt.

Knowledge Prerequisite: Deep knowledge of Python, SIP, C++ and Qt.

Mentor: Boudewijn Rempt

Project: Improve Normal Mapping Workflow

Brief explanation: Normal maps are textures that describe surface detail on a 3d model by describing how much each pixel deviates from the surface the texture is put on. A normal map gives the ability to tell the renderer there's a different normal per texel(texture pixel), this way, you can describe subtle differences in surface without requiring the polygons for it. It does so by describing the normal angle to the surface by using the R, G and B channels. Now, normal maps, due to them being quite mathematical, are usually baked. But these bakes are not always perfect. furthermore, there's a lot of interest into handpainting textures, amongst which normal maps.

Expected results: by the end of the summer, a new brush engine, which takes the tilt-direction and has that control the redness and greenness. And then takes the tilt-elevation, and has that control the blueness.

Knowledge Prerequisite: knowledge of C++, Qt. and mathematics

Mentor: Boudewijn Rempt

Calligra

Project: Variable thickness lines

Brief explanation: One of the most fundamental basics of drawing is varying the width of your lines to show shape, form and perspective. Almost every line tapers at either end, and often gets thicker and thinner in different places as needed. For purely technical and histrorical reasons though, every vector program (Illustrator, Inkscape, Karbon etc) make curves all one hard width. This proposal is to create a variable width path shape / tool, much like the path tool, would allow drawing curves, but where each node could have its width set so that the line width changed smoothly from node to node. As a plugin for the Calligra suite, this would clearly benefit apps as Karbon and also Krita.

Expected results: variable width path tool is able to change the width of any path node to an arbitary percentage (say 155%) of the stroke width. See http://bugsfiles.kde.org/attachment.cgi?id=56995 for mockup. The shape needs to be able to save and load in svg/odf.

Knowledge Prerequisite: C++, Qt, SVG

Mentor: Thorsten Zachmann < zachmann @ kde dot org >

KIOSK

Project: KIOSK Tool

Brief explanation: Back in KDE 3 there was a tool to help administrators to configure the KDE Kiosk framework. The idea of this project is to start working on a new tool. The new application should be developed in close collaboration with the Visual Design Group to get a useful application for the targeted audience.

Expected results: a functional prototype for a new Kiosk tool with a working backend to configure and restrict actions and configuration options.

Knowledge Prerequisite: C++/Qt

Mentor: Martin Gräßlin <[email protected]>

Kubuntu

Project: Port Ubiquity to Qt 5

Brief explanation: Ubiquity is the installer for Kubuntu. It should be ported to Qt 5. It is written in Python and can be fiddly to test because much of the development needs to be done on a live system. Once the Qt 5 port is complete there are numerous other bugs that can be fixed. Drop into #kubuntu-devel to say hi. Code is in launchpad.net/ubiquity. Contact: Kubuntu-devel list.

Expected results: Ubiquity bug free and running with Qt 5

Knowledge Prerequisite: Python, PyQt

Mentor: Jonathan Riddell

Calamares

Calamares is a distribution-independent installer framework (code). Calamares is participating to Google Summer of Code with KDE as umbrella organization. We are a young project, we are developing quickly, we are working with state of the art technologies (C++11, Qt 5, KDE Frameworks 5, Boost.Python) and we are solving exciting problems.

Calamares is already shipped or is about to be shipped as the default system installer for several Linux distributions, including KaOS, BBQLinux, Fedora KDE, Manjaro, Netrunner Rolling, OpenMandriva, Tanglu, and others.

See this post for instructions on how to structure your Google Summer of Code proposal for Calamares.

Project: Python interface refactor + Python view modules

Brief explanation: Calamares is just a job executor at its core, and Calamares jobs are provided by Calamares modules. Installer pages are also provided by Calamares modules. These modules can currently be written in C++11 (as Qt plugins) or Python. The Python interface *works*, but it is slightly different from the C++ one, and it only supports jobs, not installer pages. This Google Summer of Code project is one of several that start with the same initial subtask, and then branch out in different directions.

0) Refactor the Python interface so that writing a job module is not just implementing a function that expects globals, but rather inheriting from Calamares::Job or a wrapper thereof. Port all the Python modules to this updated interface. PythonQt 3.0 has just been released with support for Qt 5, so this is an option too, as a replacement for Boost.Python.

1) Further improve the Python interface to allow writing view modules (i.e. installer pages) in Python. The student should do some research on the strengths and weaknesses of different approaches and produce a detailed action plan on what to wrap, how to wrap it, and which technologies to use to achieve said goals.

Once both subtasks are complete there are various related tasks to be done. Drop into #calamares to say hi and discuss your proposal.

Expected results: Equivalence between the Python and C++ module interfaces, for both job modules and view modules.

Knowledge Prerequisite: At least some C++ experience is required; experience with CMake, Python, Boost.Python and other language binding solutions (PyQt, SWIG...) is a plus.

Mentor: Teo Mrnjavac <[email protected]>, teo- on Freenode

Project: Python interface refactor + Ruby modules interface

Brief explanation: Calamares is just a job executor at its core, and Calamares jobs are provided by Calamares modules. Installer pages are also provided by Calamares modules. These modules can currently be written in C++11 (as Qt plugins) or Python. The Python interface *works*, but it is slightly different from the C++ one, and it only supports jobs, not installer pages. This Google Summer of Code project is one of several that start with the same initial subtask, and then branch out in different directions.

0) Refactor the Python interface so that writing a job module is not just implementing a function that expects globals, but rather inheriting from Calamares::Job or a wrapper thereof. Port all the Python modules to this updated interface. PythonQt 3.0 has just been released with support for Qt 5, so this is an option too, as a replacement for Boost.Python.

1) After completing subtask 0 for Python modules, achieve the same level of support for Ruby. The student should research technologies such as SWIG, RubyInline, FFI and Rice and produce a detailed action plan on how to deliver a Ruby interface for Calamares job modules. The latter (Rice) seems to be the most promising for the kind of embedding we need and most similar to Boost.Python, but this must be further ascertained. Packaging and deployment should also be taken into account.

Once both subtasks are complete there are various related tasks to be done. Drop into #calamares to say hi and discuss your proposal.

Expected results: Equivalence between the Python, Ruby and C++ job module interfaces.

Knowledge Prerequisite: At least some C++ experience is required; experience with CMake, Ruby, Python, Boost.Python and other language binding solutions (PyQt, SWIG...) is a plus.

Mentor: Teo Mrnjavac <[email protected]>, teo- on Freenode; Rohan Garg <[email protected]>, shadeslayer on Freenode

Project: Python interface refactor + Python testing mechanism

Brief explanation: Calamares is just a job executor at its core, and Calamares jobs are provided by Calamares modules. Installer pages are also provided by Calamares modules. These modules can currently be written in C++11 (as Qt plugins) or Python. The Python interface *works*, but it is slightly different from the C++ one, and it only supports jobs, not installer pages. This Google Summer of Code project is one of several that start with the same initial subtask, and then branch out in different directions.

0) Refactor the Python interface so that writing a job module is not just implementing a function that expects globals, but rather inheriting from Calamares::Job or a wrapper thereof. Port all the Python modules to this updated interface. PythonQt 3.0 has just been released with support for Qt 5, so this is an option too, as a replacement for Boost.Python.

1) Our Python testing facilities are currently limited to a single script (src/modules/testmodule.py). The student should present an action plan for a more comprehensive testing mechanism, which may or may not be based on testmodule.py, and may or may not involve libcalamares instead. This testing mechanism could further be integrated with our Jenkins continuous integration system.

Once both subtasks are complete there are various related tasks to be done. Drop into #calamares to say hi and discuss your proposal.

Expected results: Equivalence between the Python and C++ job module interfaces, and a comprehensive testing mechanism for Python job modules.

Knowledge Prerequisite: At least some C++ and Python experience is required; experience with CMake, Boost.Python and software testing is a plus.

Mentor: Teo Mrnjavac <[email protected]>, teo- on Freenode

Project: Debian installer support

Brief explanation: Calamares is just a job executor at its core, and Calamares jobs are provided by Calamares modules. Some of these modules are common for most Linux distributions, and some might be heavily distribution-specific.

Calamares is already capable of installing a Debian-based system, simply by unpacking a squashfs image like most other distributions, but this is less than ideal: Debian already provides a sophisticated install system (debian-installer), and Calamares should take advantage of it.

The student should propose a detailed action plan, with the ultimate deliverable being one or more job modules that implement a system install procedure based on debian-installer. Additional changes to the user interface (view modules) may or may not be needed for this, depending on the feature set proposed by the student. From a top-down point of view, Calamares should behave like a debian-installer frontend, not unlike Ubiquity, but without compromising its distribution-agnostic design.

Once all the milestones have been achieved there are various related tasks to be done and bugs to be fixed. Drop into #calamares to say hi and discuss your proposal.

Expected results: Calamares should be able to install a Debian based system using debian-installer as backend.

Knowledge Prerequisite: The student should have experience with a Debian based distribution and C++; experience with Python, debian-installer and Debian packaging is a plus.

Mentors: Rohan Garg <[email protected]>, shadeslayer on Freenode; Teo Mrnjavac <[email protected]>, teo- on Freenode

Project: The Ultimate Calamares user experience

Brief explanation: Design and development of Calamares started in June 2014, with deliverables as early as Fall 2014, so some hard choices had to be made in order to ship quickly. While Calamares doesn't look intensely unpleasant when compared to some other system installers, it is not a triumph of user experience design either.

The KDE Visual Design Group has already produced a design for Calamares in agreement with the Calamares team. It is now time to implement this design.

The student should propose a detailed action plan, with the ultimate deliverable being a complete visual overhaul of Calamares, including libcalamaresui and essential view modules. Intermediate deliverables must be listed in the proposal, with as much granularity as possible. The implementation should not deviate from the KDE VDG's design unless otherwise discussed, and during the coding season the student is expected to closely cooperate with both the Calamares team and the KDE VDG.

Once all the milestones have been achieved there are various related tasks to be done and bugs to be fixed. Drop into #calamares to say hi and discuss your proposal.

Attention: This is a very challenging task, somewhat more demanding than the other ones we offer, and suitable for more experienced students. First time students are encouraged to consider our Python, Ruby or Debian tasks too. Exceptionally for this project we are requiring a qualification task to be completed by the prospective student. This qualification task should be delivered as a patch against master and sent to the mentor (Teo Mrnjavac <[email protected]>) before submitting a proposal for this project idea through the Google Summer of Code web application. Applicants that have not submitted a qualification task for this project will not be considered. The qualification task is defined as follows: implement the KDE VDG's design for the Users page (the Calamares module "users"). The webcam picture feature does not have to be implemented, but the avatar chooser is required. See this mockup.

Expected results: Calamares should look and feel as designed by the KDE Visual Design Group.

Knowledge Prerequisite: The student should have experience with Qt and C++; QML experience is a big plus.

Mentors: Teo Mrnjavac <[email protected]>, teo- on Freenode

Kopete

Kopete is an instant messenger supporting AIM, Bonjour, Gadu-Gadu, GroupWise, ICQ, Jabber (XMPP, Google Talk, Facebook, ...), Meanwhile, QQ, Skype, Windows Live Messenger, WinPopup, Yahoo and more. It is designed to be a flexible and extensible multi-protocol system suitable for personal and enterprise use.

Project: Better history plugin

Brief explanation: History plugin is responsible for archiving chat history and also searching for old chat messages in archive. Currently Kopete has two history plugins: one which stores data to XML files and another one which stores data to SQLite database. Both plugins have some diffetent limitations like slow speed, bad search support, bad support for HTML messages, bad support for multiuser chat... This project aims to fix existing history plugin(s) or designing & implementing new one.

Expected results: Working fast chat history plugin with support for handling HTML messages, multichat messages, ability to search for messages in history, import/export feature (importing from services like googletalk/facebook can be great too), ...

Knowledge Prerequisite: C++/Qt, XML or SQLite (or any other data storage usefull for chat messages)

Mentor: Pali Rohár <[email protected]>, Pali on #kopete

Co-Mentor: Kaushik Saurabh <[email protected]>, roide on #kopete

Mailing list: [email protected] (archive at: lists.kde.org)

Project: Jabber message archive

Brief explanation: When you use more jabber clients and you want to have full chat history in all clients, you need to synchronize message history between all clients. To make it easier for different jabber clients, there is jabber protocol extension for storing history directly on jabber servers which allows clients to download (missing) messages:

XEP-0136: Message Archiving

XEP-0313: Message Archive Management

Expected results: Working support for XEP-0136 or XEP-0313

Knowledge Prerequisite: C++/Qt, Jabber protocol

Mentor: Pali Rohár <[email protected]>, Pali on #kopete

Mailing list: [email protected] (archive at: lists.kde.org)

Project: PGP plugin

Brief explanation: Kopete has plugin which can sign or encrypt outgoing messages using GPG. It can also verify signature and decrypt incoming messages. This plugin is old, uses private kdepim library and needs fixing. It is hard to compile and use it. For this project I would except fixing this plugin to work again or writing new PGP plugin from scratch.

Expected results: Working support for PGP in Kopete

Knowledge Prerequisite: C++/Qt, GPG

Mentor: Pali Rohár <[email protected]>, Pali on #kopete

Mailing list: k[email protected] (archive at: lists.kde.org)

Project: IRC protocol

Brief explanation: Kopete KDE3 version had plugin for IRC protocol. Porting that IRC plugin to new KDE versions was never finished and Kopete does not have working support for IRC yet.

Expected results: Restore IRC protocol into Kopete

Knowledge Prerequisite: C++/Qt, IRC protocol

Mentor: Pali Rohár <[email protected]>, Pali on #kopete

Mailing list: [email protected] (archive at: lists.kde.org)

Libreoffice

Project: Port Libreoffice skin to Qt 5

Brief explanation: LibreOffice uses its own widget toolkit. This gets skinned in various ways by Qt and other toolkits. There is a skin for Qt 4 but not for Qt 5.

Expected results: LibreOffice widgets looks like Qt 5 widgets

Knowledge Prerequisite: C++/Qt, git

Mentor: Jonathan Riddell <[email protected]> Riddell on #kde-devel

Co-Mentor:

This patch takes the "kde4" skin and renames it to "kde5" still using Qt 4. It can be used as the start framework to port to Qt 5. https://gerrit.libreoffice.org/#/c/13078/