GSoC/2015/Ideas: Difference between revisions

Note

Work in progress, proposals here are often copied from the GSoC 2014 list

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.

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

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!

(projects to appear here. Please ask in #marble in the meantime)

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 1 week of development for a basic 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)

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!

KDE Telepathy

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: Make Libbluedevil Async

Brief explanation: Extend libbluedevil to have an asynchronous api, and port bluedevil to it.

Expected results: libbluedevil should have an asynchronous api, and bluedevil should be ported to them.

Knowledge Prerequisite: basic Qt and DBus

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

Resources: libbluedevil, bluedevil, afiestas

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.

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 bla bla

Project: Integrate Animation in Krita's core

Brief explanation: bla bla

Expected results: bla.

Knowledge Prerequisite: C++/Qt at least.

Mentor: Boudewijn Rempt

@@ Line 533: / Line 533: @@
 [[Category:Mentoring]]
+=== Krita ===
+[http://www.krita.org Krita] bla bla
+==== Project: Integrate Animation in Krita's core ====
+'''Brief explanation:'''  bla bla
+'''Expected results:''' bla.
+'''Knowledge Prerequisite:''' C++/Qt at least.
+'''Mentor:''' Boudewijn Rempt

Revision as of 14:14, 17 February 2015

Guidelines

Information for Students

Adding a Proposal

Project:

Ideas

Your Own Idea

Project: Something that you're totally excited about

Kdenlive

Project: Add support for new Animation capabilities

Project: Redesign titler using WebVFX

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

Project: make Kdenlive work on Windows and OSX

Amarok

Project: Port Amarok to Qt5/Kf5/Plasma5

digiKam

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

Project: Advanced Metadata HUB

Project: Add WebP and WebM support

Marble

KStars

Project: Ekos Scheduler

Project: Constellation art

Project: Fix our deep-sky data handling

Project: Propose your own project

KDE Edu

Project: Integrate Cantor into LabPlot

Project: Integrate VTK into LabPlot, investigate Tulip

Project: Port of GCompris in Qt Quick

Keyboard Layouts

Project: Integrating Input Methods with keyboard layout configuration

KDevelop

Project: Clang Integration

Project: Checker Framework

Project: SVN Plugin Rewrite

Project: LLDB Support

KDE PIM

Project: OpenHolidays

Project: QtQuick ToDo API / Plasmoid

Simon

Project: Streamline handling of various resources

KDE Telepathy

Okular

Project: Better Accessibility for Okular

Project: Implement PDF Poppler features

Project: Implement SecurityHandler V6 in Poppler

KDE Connect

Project: Improve KDE Connect encryption

Project: Build a Qt-only multiplatform KDEConnect client

Solid

Project: Make Libbluedevil Async

Project: Improve sharing experience

Muon

Project: Better support for your distribution

KWin

Project: DRM/KMS backend for kwin_wayland

Trojitá

Gluon

Project: Build a QtQml based script system

Project: Expand Gluon Input

Krita

Project: Integrate Animation in Krita's core