GSoC/2018/Ideas - KDE Community Wiki

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.

Note

These are all proposals! We are open to new ideas you might have!! 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.

Adding a Proposal

Note

Follow the template of other proposals!

Project:

If appropriate, screenshot or other image

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.

Krita

Krita: digital painting for artists. 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.

Krita is a widely used digital painting application for professional artists. Last year, Krita gained the ability to create hand-drawn 2D animations, among other new features. For this year, projects that the Krita team would be interested in include the following ideas.

Note that we're always open to ideas you bring in yourself: if you're passionate about something you've come up with yourself, that you want for Krita, that's a big plus for us.

We also expect prospective students to submit at least three patchs for bugs or wishes or small features. We want to know how good you are! See https://phabricator.kde.org/T7724 for some smaller tasks that you could work on that are not bugs.

Project: Optimize multithreading in Krita's Tile Manager (make the hash table lockfree)

Brief explanation: This is a hard-core project, only suitable for someone with deep knowledge of the problems of designing multi-threaded software. It involves Krita's core datamodel, where the tiles that compose image data are managed. The main problem is that at the moment the core utilizes QReadWriteLock and QMutex a lot, which means that Krita painting performance stops scaling well, when the number of CPU cores becomes larger than 8. The goal of this project is to locate all the bottlenecks (there are at least 4 of them) and resolve them in a lock-free. One of the bottlenecks involves KisTileHashTable which is used to access the tiles. Since this touches the very core of Krita, a thorough test plan is essential.

Steps to apply: The topic of the project is quite advanced, so we recommend you to do the following steps before writing a proposal:

Build Krita with unittests enabled
Install GNU Perf or VTune
Run FreehandStrokeBenchmark in a profiler and try to locate all the places where most of the locking/waits happen. The main one will be the hash table, but there are at least three more (your task is to locate them and add into your proposal!)
(optional) To test your coding abilities you can try to port one of the hash tables code from Junction library to Qt's primitives. If you don't feel overwhelmed with such code, you are perfectly fit for the project!
And feel free to contact Krita developers, if you have any question during these steps!

Expected results: No bottlenecks anymore!

Knowledge Prerequisite: C++, Qt, threads, locks.

Mentor: Dmitry Kazakov (dmkitryK|log on irc)

Project: Extending Animation Support for curves

Brief Explanation: In Krita, you can already add curves that could be applied to some properties of a layer, like opactity, animating those properties. We want the animation support extended by allowing users to place masks (filter masks, transformation masks, transparency masks) on the timeline and animate their properties using curves. Every property of a layer or mask placed on the timeline should be animatable.

Expected results:

Implementation of a gui for applying the curve settings to one or more properties of a mask or layer
Implementation of the actual rendering of the properties in the frames
Saving of these settings

Knowledge Prerequisite:

C++ and Qt

Mentor: Boudewijn Rempt (IRC: boud) or Dmitry Kazakov (IRC: dmitryk_log)

Project: Taking the Shape Brush to the next level

Brief Explanation: Krita has a number of interesting brush engines. One of them is the Shape Brush engine. Inspired by Alchemy, the shape brush "throws" shapes on the canvas. The current implementation is limited to geometric shapes. We want the brush engine to be extended to make it possible to load vector shapes defined as PDF or SVG and use those to draw on the canvas as well. Other improvements are the addition of Feathering, an outline mode, edge sharpening and background textures.

Expected Results: A revampted and exciting shapes brush

Knowledge Prerequisite:

C++, Qt, Krita

Mentor: Boudewijn Rempt (IRC: boud) or Lukas Tvrdy (IRC: LukasT)

Project: Analysis of thoroughput of Krita Blending Modes and porting them to AVX2

Brief Explanation: Blending modes is the hottest piece of code in Krita. It should process gigabytes of data per second, therefore it should be extremely optimized. Some of its parts are already optimized to use AVX instructions, but some (float16 color spaces) are not. We need to port the rest of the color spaces to AVX and make a research into the possibilities of using AXV2 instructions directly (int16 instructions). Vc library supports AXV2 instructions, though we don't know to what extent, it might happen that you would need to extent the library itself to get the needed functionality. This is another hard-core project only suitable if you have a good deal of experience.

Steps to apply: The topic of the project is quite advanced, so we recommend you to do the following steps before writing a proposal:

Build Krita with unittests enabled
Install GNU Perf or VTune
Run KisCompositionBenchmark under a profiler and see the hottest places of blending modes code
Check the code of "Normal" blending mode for float32 color spaces (KoOptimizedCompositeOpOver128), copy the file and try to create you own blending mode for float16 color space. Hint: the only thing you should do is to implement correct unpacking/packing code that would convert the values to 32-bit float and back.
If you don't feel overwhelmed with such code, you are perfectly fit for the project!
And feel free to contact Krita developers, if you have any question during these steps!

Expected Results: Float16 color spaces are ported to AVX, Integer8 and Integer16 colorspaces are ported to AVX2

Knowledge Prerequisite: C++, SEE/AVX (read Intel's manual)

Mentor: Dmitry Kazakov (IRC: dmitryk|log)

Project: Port generic code for not-so-popular blending modes to AVX

Brief Explanation: In Krita we have a lot of blending modes, but only Normal and Alpha Darken are optimized and ported to AVX instructions. The reason for that is obvious, these two blending modes are the hottest and are used in every single image produced in Krita. But it doesn't mean that the other blending modes are less important for painters: they still use Multiply for painting shadows, and Linear Dodge for painting highlights, so they should also be fast!

The good piece of news is that all these "non-popular" blending modes are implemented in Krita by means of a single class KoCompositeOpGenericSC, so, basically, as a result of your project you should provide one class only! The bad piece of news is that this single class implements about a hundred of blending modes using C++ templates... so be prepared! :)

Steps to apply: The topic of the project is quite advanced, so we recommend you to do the following steps before writing a proposal:

Build Krita with unittests enabled
Install GNU Perf or VTune
Run KisCompositionBenchmark under a profiler and see the hottest places of blending modes code
Check the code of "Copy" blending mode in KoCompositeOpCopy2 and try to port it into AVX for RGB8 colorspace. Use KoOptimizedCompositeOpOver32 as an example.
If you don't feel overwhelmed with such code, you are perfectly fit for the project!
And feel free to contact Krita developers, if you have any question during these steps!

Expected Results: "Copy" blending mode is ported to AVX, all the "gereric" blending modes are ported to AVX

Knowledge Prerequisite: C++, SEE/AVX (read Intel's manual)

Mentor: Dmitry Kazakov (IRC: dmitryk|log)

Project: Optimize Soft, Gaussian and Stamp brushes to use AVX

Brief Explanation: When the user draws a line in Krita, this line consists of thousands of small rectangular images (dabs) that are painted one over another. For each dab Krita generates its own mask (depending on the stylus pressure and tilt) and uses this mask for filling the layer. It happens thousands of times per second, which makes mask generation code one of the hottest places in Krita. We already have AVX optimization for Default brush mask engine and it works 5(!) times faster than Gaussian engine and 3(!) times faster than the Soft engine. The goal of this project is to port the rest of non-optimized engines to use AVX via Vc library and make them faster.

Steps to apply: The topic of the project is quite advanced, so we recommend you to do the following steps before writing a proposal:

Build Krita with unittests enabled
Install GNU Perf or VTune
Run FreehandStrokeBenchmark under a profiler and compare the results for different types of brushes. You can see how faster Default brush tip is.
Check the code in kis_brush_mask_applicator_factories.cpp and try to implement your own version of FastRowProcessor for KisGaussCircleMaskGenerator without using any AVX. Even without any vector instruction the brush will become much faster, just because it will use less virtual calls.
If you don't feel overwhelmed with the amount of C++ templates in your code, you are perfectly fit for the project!
And feel free to contact Krita developers, if you have any question during these steps!

Expected Results: Circular Soft, Gaussian and Stamp brush masks are ported to AVX-optimized code. Optionally, if there is enough time, rectangular brush masks are posted as well.

Knowledge Prerequisite: C++, SEE/AVX (read Intel's manual)

Mentor: Dmitry Kazakov (IRC: dmitryk|log)

Project: Partial canvas updates and region of interest (performance optimization for huge (20k+) canvases)

Brief Explanation: We already have an optimization for huge canvases, which is called Instant Preview. But it woks only when the user has the canvas zoomed out to fit the screen. There are some usecases, when the user wants to work with a small "working area" of a huge image and he doesn't care what happens with the rest of the image. This project is targeted to optimize this case.

Expected Results: By the end of the summer we expect these features to be implemented:

Partial updates in openGL canvas. Right now we redraw all the image textures in every frame, which is not needed after porting to Qt5.
Region of Intereset (ROI) in KisImage. Updates should be reordered and the priority should be given to the areas that are currently visible to the user
Work Area Tool. The user is be able to define the area, where he would like to work in. The updates for other parts of the image are skipped until the user exits this special mode.
(if there is time) Optimize textures loading to use RIO as well. Theoretically, we can just skip uploading of the tiles that are not visible on the screen at the moment.

Steps to apply: The topic of the project is quite advanced, so we recommend you to do the following steps before writing a proposal:

Build Krita
Check the code in KisImage, pay attention to 'cropRect' parameter of the update calls. That is exactly what you need for limiting the updates in the work area tool
Try to write Work Area Tool: copy the code of KisToolCrop, connect it to Krita and make it override the cropRect paramenter in KisImage.
If you manage to make a draft of Work Area Tool, most probably, you will manage to complete the whole project successfully!
And feel free to contact Krita developers, if you have any question during these steps!

Knowledge Prerequisite: C++, OpenGL

Mentor: Dmitry Kazakov (IRC: dmitryk|log), Julian Thijssen (IRC: Nimmy)

Project: Add 3D Painting Assistants

Brief explanation: One of the more innovative features in Krita are the painting assistants. These are shapes overlaid on the canvas that the artist can use to help him achieve perspective, straight lines and other shapes freehand. For complex drawings it would be useful to be able to place 3D models on the canvas, position and scale them and use those as guides for drawing.

Expected results: by the end of the summer, 3D models should be shown on canvas as canvas decorations, using OpenGL in hidden-line wireframe mode. The models should be manipulated using on-canvas controls like other assistants. Magnetic snapping is an optional extra.

Knowledge Prerequisite: C++, Qt, OpenGL, Assimp

Mentor: Julian Thijssen (IRC: Nimmy)

KDE Student Programs

KDE Student Programs is the working group responsible for running Season of KDE and managing KDE's participation in Google Summer of Code, Google Code-In, and other mentorship programmes.

Project: A new Season of KDE Website

Brief explanation: Season of KDE will need a new website to make managing the project easier for us. The core feature set that we're looking to have comprises:

Student applications on the website
Mentors can mark themselves interested in projects during the application phase
Org admins will create slots and assign projects and mentors to slots
Manage mid-term evaluations and results
Bulk data export and import

For maintainability by the rest of KDE we'd like the app to be in Python (Tornado or a WSGI framework). It would also be nice if the app was an SPA riding on top of a REST API server so we can have command-line tools interacting with the server as well.

Expected results: Easier project administration for KDE.

Knowledge Prerequisite: Python, Tornado/WSGI, LDAP, full-stack web development, Single-Page applications.

Mentor: Boudhayan Gupta <[email protected]>, BaloneyGeek on IRC

GCompris

Project: finishing started activities

Brief explanation: GCompris is a an educational software suite comprising of numerous activities for children aged 2 to 10. Originally written in Gtk+ it's development team started to rewrite it from scratch in Qt Quick.

Expected results: The aim of this year is to complete and getting merged activities that were started but have not been finished. You can find a list of tasks that you can work on at https://phabricator.kde.org/T7498. First phase is to check what is missing to be integrated (on code and graphic side) and then to complete them. You can find at https://cgit.kde.org/gcompris.git/refs/heads the list of the current branches (some of them need to be dropped, so contact us before starting working on one of them).

Knowledge Prerequisite:

Be interested in children’s 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: Continuing an activity already started or rewriting from scratch is something you have to check before writing your application. Provide a timeline in your application. If you haven't contributed yet please read http://gcompris.net/wiki/An_exercise_for_new_contributors and http://gcompris.net/wiki/Reviewing_an_activity

There are several info in the wiki: http://gcompris.net/wiki/Developer%27s_corner.

Feel free to contact us either on irc or by mail ([email protected])

Mentors: Divyam Madaan (IRC: dmadaan), Johnny Jazeix (IRC: JohnnyJ), Rudra Nil Basu (IRC: rudra), Timothée Giet (IRC: Animtim)

Project: Unit test framework

Expected results: The aim of this project is to build the base for unit testing for GCompris. The student will have to think on what we can test (qml, js...) and how we can put this in place. More information can be found in https://phabricator.kde.org/T7668.

Knowledge Prerequisite:

Be interested in children’s education

Be familiar with GCompris concept and content

Basic knowledge in a programming language and CMake use (a 1 year school course is enough)

Be able to build the Qt Quick version of GCompris

Technologies used are CMake, C++, Qt.

Feel free to contact us either on irc or by mail ([email protected])

Mentors: Divyam Madaan (IRC: dmadaan), Johnny Jazeix (IRC: JohnnyJ), Rudra Nil Basu (IRC: rudra), Timothée Giet (IRC: Animtim)

KDE Partition Manager

Project: finishing KAuth support [Season of KDE]

Brief explanation: KDE Partition Manager is a utility program to help you manage the disk devices, partitions and file systems on your computer. It allows you to easily create, copy, move, delete, resize without losing data, backup and restore partitions.

Expected results: Last year a lot of work was done to make KDE Partition Manager not to start as root and use KAuth to elevate privileges. The aim of this project is to finish required refactoring and make sure everything still works.

The two main issues are:

SMART support needs to be ported from (unmaitained) libatasmart library to calling smartctl command. This task is likely to be fairly easy.

KDE Partition Manager operation runner should be refactored, instead of calling KAuth helper multiple times to run a single command it has to prepare a list of all commands and their inputs and call KAuth helper once. This needs some refactoring in how partition manager reads and writes disk data (e.g. when moving/copying/backing up or restoring partition). In particular we don't want to transfer all the disk data back from the helper to the main application and back to the helper as DBus transport is fairly slow.

Knowledge Prerequisite:

Be able to build the KPMcore and KDE Partition Manager from source.

Knowledge of C++ / Qt (No knowledge of KDE Frameworks is required).

Application guide: Get in touch on IRC (#kde-devel or #calamares).

Mentors: Andrius Štikonas (IRC:stikonas)

Kopete

Project: Write tests and Improve protocol support

Brief explanation: Kopete is an instant messaging client that has the modular architecture and supports many messaging services with useful plugins to complement them.

Expected results: The aim of this project is to fix the bugs due to porting and improve the frontend and the test coverage.

Knowledge Prerequisite:

Be interested in test-driven development.

Be familiar with the codebase of KDE in general.

Knowledge of C++ / Qt.

Application guide:

Get in touch with us on mailing-list and start hacking KDE and fix bugs. Teams of two people is preferred for this project as it is a lot of work :)

You can contact on IRC also but it is better to discuss over mailing list as not many people are in IRC on #kopete channel.

Mentors: Vijay <[email protected]> (vijay_ on IRC), Kopete Mailing List <[email protected]>

LabPlot

LabPlot is a KDE-application for interactive graphing and analysis of scientific data. LabPlot provides an easy way to create, manage and edit plots and to perform data analysis.

Project: Plotting of live MQTT data

Brief explanation: LabPlot has already some support for plotting of live-data (http://krajszgsoc.blogspot.de/2017/09/in-finish-line-but-not-in-end.html). To cover more use-cases we want to also support MQTT sources. We need to investigate the available MQTT libraries for Qt:

and to add some support for MQTT to LabPlot.

Expected results: Similar to the currently supported data sources (files, sockets, serial port, SQL databases) we want to support the subscription to MQTT brockers and plotting of their data.

Knowledge Prerequisite: C++, Qt, (optional) knowledge and experience with MQTT

Mentor: Fábián Kristóf - Szabolcs (mailto:[email protected])

Project: Import of educational data sets available on the internet

Brief explanation: There are many internet pages providing data sets for educational and study purposes for many different areas (astrophysics, statistics, medicine, etc.). Some tools used in the scientific area provide some "wrappers" for such online sources and allow the user to easily play around with those data sets in the applications whereas the technical details like fetching of data from the server and parsing are done completely transparent for the user. The goal of this project is to add similar functionality to LabPlot. There will be a wizard where the user can select from a thematically grouped list of data sets available online. The internal description of such an online data set should contain the URL with the actual file that needs to be downloaded and the settings for LabPlot's data parser (separator, column names and data types, etc.). The data fetched once should be cached so there is no need to fetch from the web again. Here we can have a look maybe at KStars for how to implement such a caching strategy and maybe even re-use some code from KStars. In addition to the list of pre-defined online sources, we need to elaborate how the user can add new online data sets (together with all the required parametrization) and publish the settings to make them available for everybody.

Expected results: We want to be able to easily import the educational data sets available on the internet.

Knowledge Prerequisite: C++, Qt

Mentor: Stefan Gerlach

Project: Import of data from web-services

Brief explanation: Brief explanation: This goal of this project is to extend the number of supported data sources by adding the possibility to import the data from web services (live and historical financial data, weather, etc.). Most web services expose their data via JSON. We need to add a "JSON filter" to LabPlot capable to connect to a web service, to fetch the data, to parse it and to import into LabPlot's internal data containers. In the GUI the user should be guided through the entry of the service URL, additional services parameters like API token, etc. and through the settings for the actual parsing (which JSON fields to consume and how). Also, it should be possible to refresh the data periodically like it is already possible for the live data (http://krajszgsoc.blogspot.de/2017/09/in-finish-line-but-not-in-end.html). The goal is also to provide a set of widely known web services so the user can select and import the data from a list of pre-defined services. In addition to this, we need to elaborate the possibility to "publish" the settings for a web-service done by the user and make them publicly available to every LabPlot user.

Expected results: Similar to the currently supported data sources (files, sockets, serial port, SQL databases) we want to import the data from web services and visualize it.

Knowledge Prerequisite: C++, Qt, (optional) JSON support in Qt

Mentor: Alexander Semke

Kdenlive

Kdenlive is a KDE-application for professionnal video editors. It supports hundreds of video formats, and all the features you can expect from a non-linear video editor, including some advanced features like timeline preview rendering, proxy clips and more.

Choqok

Project: Port Choqok to Kirigami

Brief explanation: Current Choqok UI doesn't make use of QML and creates interfaces in C++ files. The idea is to rewrite the interface in QML. At this point is better doing it with Kirigami since this means it will work on Plasma Mobile too.

Expected results: Choqok UI makes use of Kirigami.

Knowledge Prerequisite: C++, Qt, Qml

Mentor: Andrea Scarpino (IRC: ilpianista)

Application guide: Get in touch on IRC (#choqok).

KStars

KStars is free, open source, cross-platform Astronomy Software. It provides an accurate graphical simulation of the night sky, from any location on Earth, at any date and time.

Project: Deep Sky Object Overhaul

Brief explanation: KStars supports many deep sky objects (DSOs) including galaxies, nebulae, supernovae, clusters and more. Currently, some deep sky catalogs are stored in simple space separated text format where they are parsed into KStars directly or into KStars Deep Sky Component SQLite3 database which is then loaded in KStars. However, since all DSOs are loaded at once into memory, this limits the size of catalogs within KStars. A solution similar to how dynamic stars are cached in and out of memory must be developed for DSOs. Furthermore, all catalog entries should have their trixels indexed so that they can be efficiently drawn unto the sky map. Another issue is that catalogs can overlap since there is no cross-identification of various catalogs. For example, Andromeda galaxy exists in Messier catalog as M31, and exists in NGC catalog as NGC 224. The database should support ability to cross-identify objects from all supported and future catalogs.

Expected results:

Convert all text-format catalogs to SQLite3 database.
Develop master DSO database where cross-identification of objects is supported. Master database can supported addon downloadable catalogs where they can be merged once downloaded by the user.
Import of The Principal Galaxy Catalog, 2003 Version (PGC2003) which contains ~1 million galaxies into KStars as a downloadable addon.
Caching and drawing optimizations for large catalogs.
Cross-identification for all supported DSO catalogs including, but not limited too: NGC/IC/Messier/Arp/PGC/LDN
Trixel indexation for all DSOs. Implementation of improved drawing cached routine in KStars for DSOs similar to stars.
All necessary updates within KStars maps, tools and dialogs to reflect the above changes.

Knowledge Prerequisite: C++, Qt, Data Structures

Mentor: Jasem Mutlaq (Matrix: Jasem)

Project: Implementing Ekos in KStars Lite

Brief explanation: Ekos is KStars premier tool for observatory control and automation. KStars Lite was successfully developed in GSoC 2016 and is available for Android phones and tablets. We would like to extend KStars Lite to include basic support for Ekos. Currently, KStars Lite supports basic telescope and capture controls, but it could be extended to support a richer experience for users who are performing observatory control and astrophotography.

Expected results:

Telescope floating motion controls including speed controls.
Like video feed display from supported devices.
Image capture with binning, count, exposure, ISO..etc controls similar to Ekos desktop client.
Focus controls.
Alignment using remote astrometry.

Knowledge Prerequisite: C++, Qt, QML

Mentor: Jasem Mutlaq (Matrix: Jasem)

Project: Ekos Web Client

Brief explanation: Ekos is KStars premier tool for observatory control and automation. A web client port of Ekos is desired where it communicates with the underlying INDI servers and drivers without a direct dependency on thick desktop clients. Ekos includes many modules including setup, capture, focus, guide, align, and mount. All functionalities of the desktop Ekos client are expected in the web client version using Python+Ajax or similar framework technologies suitable for online dynamic driven clients.

Expected results:

Online Ekos web client with all the thick client feature set.
Authentication and Registration framework.
Support for notifications similar to desktop client.
Ajax dynamic driven interface with near real time updates for framing and captures.
Multi-user support with granular permissions.
Web based INDI Control Panel with all the driver controls as in the desktop version.

Knowledge Prerequisite: C++, Qt, Django/Ajax or similar technology framework.

Mentor: Jasem Mutlaq (Matrix: Jasem)

Project: Implement Qt3D backend for KStars

Brief explanation: The Skymap in KStars desktop version is currently built using QPainter and 2D drawing primitives. In order to take advantage of advances in modern GPU hardware and to present a stunning visual view of the night sky, a 3D backend is desired. Qt 3D provides functionality for near-realtime simulation systems with support for 2D and 3D rendering in both Qt C++ and Qt Quick applications. Within KStars, SkyPainter provides a backend-agnostic class for drawing object unto the skymap regardless of the backend. Previously, an experimental OpenGL backend was developed but was later deprecated due to drawing issues. Since Qt3D provides an abstraction to the backend framework (OpenGL/Vulkan/DirectX), it presents a very flexible framework for building future-proof 3D applications.

Expected results:

Create Qt3D based backend to draw all objects currently implemented by QPainter backend.
Create realistic colors, shares, textures, meshes, lighting for all stars, solar system, and deep sky objects.
Create animations for meteor shows, comet tails, stars twinkle..etc

Knowledge Prerequisite: C++, Qt, Prior experience working with 3D applications/games.

Mentor: Akarsh Simha (Matrix: kstar)

Peruse

Peruse is a comic book reader application by KDE, which is designed to work both on touch based devices, and on the traditional desktop. Additionally, it has a tool called Peruse Creator which is designed to create comic books for use with Peruse and any other CBZ capable comic book reader. It has rudimentary support for the Advanced Comic Book Format, which is a metadata container for comic book archives (CBR, CBZ and so on).

See also the Peruse website for more detailed information: https://peruse.kde.org/

Project: Expand Creator's Abilities

Brief explanation: Peruse Creator is currently very simple, and will allow the user to create a CBZ comic book archive annotated with a subset of the Advanced Comic Book Format (ACBF) metainfo, such as authors, publisher information, characters and so on. It does not allow for the creation or editing of the viewport based navigation that ACBF describes, nor does it support the text layers system ACBF proposes for comic book translation. It also lacks editor components for a variety of the general metainformation ACBF suggests.

Your project proposal should include explicit descriptions of which of these you wish to build support for, and how you propose to do so. It should further include timeframes for each.

Expected results: A more capable Peruse Creator.

Knowledge Prerequisite: C++ and Qt required, additionally QML/QtQuick knowledge is preferred

Mentor: Dan Leinir Turthra Jensen ([email protected], IRC: leinir, Telegram and twitter: @leinir)

Project: New Viewer Component

Brief explanation: The current viewer component for Comic Book Archives (CBR) in Peruse is a simple full-page viewer, which only supports page-by-page navigation. The Advanced Comic Book Format (ACBF) metadata container brings with it support for a viewport system, which describes how the application should present specific sub-sections of each page, as well as a system for navigating between arbitrary pages in the comic.

Your project proposal should include explicit descriptions of how you would suggest to implement this, as well as a schedule for the work.

Expected results: A viewer component which is able to consume and display the viewport based navigation metadata from the ACBF container, as well as present the general metainformation to the user.

Knowledge Prerequisite: C++ and Qt required, additionally QML/QtQuick knowledge is preferred

Mentor: Dan Leinir Turthra Jensen ([email protected], IRC: leinir, Telegram and twitter: @leinir)

KGpg

KGpg is a frontend for GnuPG key management.

Brief explanation: KGpg currently consists of one application with a very narrow external interface, which is available via DBus. The goal is to split out parts of the code into a static library that is used both by the KGpg binary as well as to-be-written unit tests, which should also cover at least all of the "transaction" classes.

Expected results: unit tests that can be called via CTest, and are integrated into the KDE CI jobs

Knowledge Prerequisite: basic C++, CMake, and GnuPG usage

Mentor: Rolf Eike Beer ([email protected], IRC: Dakon)

Plasma

Improve handling for touchpads and mice with Libinput

Brief explanation: Libinput is now used as the driver for input devices in most distros. However, System Settings does not present the user with good interfaces for configuring input devices with libinput. Currently the only well-supported use case is for touchpads in a Wayland session. For touchpads on X11, and mice on both X11 and Wayland, the user experience is sub-optimal or non-existent.

Expected results: System Settings should expose good user interfaces for configuring both touchpads and mice when using Libinput, and for both Wayland and X11.

Knowledge Prerequisite: C++, Qt

Mentor: Nate Graham (Email: [email protected]; Telegram: @nggraham)

Application guide:

Discover: fwupd integration

Brief explanation: Discover Software Center is in charge of offering different kinds of assets at the moment. Applications, Add-ons, etc as well as serving updates. At the moment it's still not able to update our devices' firmwares. There's a tool for GNU/Linux called FWUPD to do so: https://fwupd.org/developers

Despite the description specifying plasma, the end goal is to provide a seamless solution to have your hardware's firmware up to date. If the proposal is too short, other improvements suggested to add to the idea will be welcome.

Expected results: Plasma being great at having an up to date system, also with hardware.

Knowledge Prerequisite: C++ and Qt, also notions of how glib works, to understand upstream FWUPD.

Mentor: Aleix Pol: apol, @AleixPol, [email protected]

Okular

Add support for showing and adding replies to sticky notes

Brief explanation: PDF files can contain replies to certain annotations, you would need to add support to Okular and potential poppler so that they show the same way they do on other PDF readers. Once they are shown and if there is enough time adding the capability to add replies is also welcome.

Knowledge Prerequisite: C++, Qt

Mentor: Okular developers https://mail.kde.org/mailman/listinfo/okular-devel

Application guide:

https://bugs.kde.org/show_bug.cgi?id=387834

WikiToLearn

You can find all of the WikiToLearn community on chat.wikitolearn.org. We have many other ideas: get in touch with us to discuss them further!

Project: WTL as a progressive web app

Brief explanation: PWA is being used in the first iteration of the new WikiToLearn architecture. It needs some improvement in terms of testing, offline-experience and organization to make it stable and ready for a first stable release. We want, also, to create a cohesively ecosystem of resources and design guidelines that can be easily reused. Main goal of this project is to enhance the existing project to provide a tested, functional and production-ready PWA.

Expected results:

Improve documentation
Write design guidelines for people who want to contribute
Organize shared resources in a reusable manner
Write unit and integration test
Implement functional offline browsing
Enhance UX for a production-ready release

Knowledge Prerequisite:

Knowledge of Vue
Knowledge of HTML5, CSS3 (Sass/Less), JS (ES6 and Browser Apis)
Responsive design
Build Tools (WebPack)
Standards and best practices in Web Development

Mentor: Gianluca Rigoletti (@rigolo)