GSoC/2019/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 are urged to contact the developers and find out more about the particular suggestion you're looking at.

Becoming 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 rarely works.

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 another 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)

- Ideas with no mentors listed and their contact info will be removed **

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.

Cantor

Cantor provides a graphical frontend for different open source computer algebra systems and scientific programming languages. Contact the KDE-Edu team.

Contact KDE-Edu

Project: Integrated documentation

Brief explanation: at the moment the external documentation like for example for Maxima http://maxima.sourceforge.net/docs/manual/en/maxima.html, and similar for Octave, python, etc., is opened in the external browser window. Ideally, we'd show this inside of the application in the help/documentation panel and enable a quick access to the documentation together with some more advanced search capabilities. Integrated search and also the context sensitive help (user marks a keyword in the worksheet, hits e.g. the F1 button and the documentation for the selected keyword is shown) should be possible. Qt Help Framework (http://doc.qt.io/qt-5/qthelp-framework.html) should be utilized for this. For indexing and searching in a unified manner the documentation together with the search index should be available locally. Qt help's qch file should be available for download on store.kde.org. Users of different systems (Maxima, Octave, R, etc.) would download the documentation they need. Ideally, we could also try to get a similar appearance by css-styling the html files for different systems prior to creating those qch files.

The project consists of the following three major parts:

implementation in c++ (documentation panel, searching, short cuts for faster navigation, etc.)
creation of Qt help files for major computer algebra systems and programming languages supported by Cantor
definition of sections on store.kde.org

Expected results: integrated documentation in Cantor for the supported CAS and programming languages

Knowledge Prerequisite: C++, Qt, basic knowledge about html

Mentor: Alexander Semke

digiKam

digiKam is an advanced digital photo management application for Linux, Windows, and MacOS.

Project: AI Face Recognition with OpenCV DNN module

Brief Explanation: With GSoC 2016, we proposed a project to implement an AI extension to the digiKam core face recognition. The project used the Dlib C++ API, but we were not satisfied by the results, as the algorithm gave poor performance. This choice also introduced a huge backport of low level codes which we don't want to maintain. So, even though the project proposed a somewhat suitable solution to provide an AI face recognition processor based on deep-learning, this one was not really powerful and functional enough. For now, this section of code about Dlib DNN extension is disabled in digiKam core.

As digiKam core already depends on OpenCV library to perform complex image processing, and as OpenCV >= 3.3 release provide a new OpenCV DNN (Deep Neural Network) module, the goal now is to port the current digiKam core face recognition DNN extension to new OpenCV API and write all unit tests to validate the algorithm usability, efficiency, and performance, while learning and recognizing faces automatically.

Expected Results:

Provide a suitable Face recognition based on DNN OpenCV API, with unit test, and documentation.

Knowledge Prerequisite:

C, C++, Qt, OpenCV, digiKam

Mentors: Maik Qualmann ([email protected]) and Gilles Caulier ([email protected])

Project: Faces Management workflow improvements

Brief Explanation: digiKam provide a Faces detection algorithm which work mostly in 80% of use cases. It detect faces position in image automatically and register these information in database. Event if a lots of tasks can be done in background by digiKam, the end-users needs to adjust, re-organize, rename, delete Face tags in database through the user interface.

Since many year, a lots of improvements have been identified by digiKam users community to improve the face tags management workflow in graphical use interface. See this list of bugzilla entries for details

Note: Face Recognition is another part of Faces management, but this project is concerned by algorithms used while recognition.

Expected Results:

Provide a better Face Tags management workflow in user interface, with unit test, and documentation.

Knowledge Prerequisite:

C, C++, Qt, User interface, digiKam

Mentors: Gilles Caulier ([email protected])

Project: Zoomable and Resizable Brush for Healing Clone Tool

Brief Explanation: With GoSC 2016, we have proposed a project to implement an Healing Clone tool for digiKam image editor to be able to remove unwanted artifacts from images. The student has implemented the basis without a zoomable canvas and without the resizable brush support. Due to this lack of features, the tools cannot be used in production by end-users.

This section of code about healing clone tool is currently disabled in digiKam core.

The goal of this project is to implement the missing feature for the Healing Clone tool in image editor, including the unit-tests and the documentation.

Expected Results:

Provide a suitable Healing clone tool for image editor, with unit tests, and documentation.

Knowledge Prerequisite:

C, C++, Qt, digiKam

Mentors: Mohamed Anwer ([email protected]) and Gilles Caulier ([email protected])

Project: Factoring all Export Tools with new Export API

Brief Explanation: With GoSC 2018, we proposed a project to implement a huge factorization and improvements with all digiKam export to web service tools. Our student fixed plenty of code using OAuth version 2 authentification, has simplified classes, and started to write a new API to factorize all these tools, including a common Wizard dialog. Even if the export tools implementation are now better, they do not use the new API and always run as a stand alone session in digiKam core. Due to this fact, the Web Service tools are not yet usable in digiKam Batch Queue Manager as single step runnable at end of a queue processing. So the section of code about factored export tools API is currently disabled in digiKam core. This year, the project will be to fix that.

Expected Results:

Start to use every the new export tools API, use the new Wizard dialog, factoring codes everywhere, and introduce all export tools to BQM. Write unit tests, and documentation.

Knowledge Prerequisite:

C, C++, Qt, digiKam

Mentors: Maik Qualmann ([email protected]) and Gilles Caulier ([email protected])

Falkon

Falkon is a KDE web browser.

Contact the Falkon team

Plasma integration

Brief explanation: Falkon is Qt application and as such it integrates quite well into Plasma desktop environment. There is also an extension that allows to store passwords in KWallet. Plasma desktop provides some services that could be useful to use from browser, like showing the progress of downloads as jobs in notification applet or searching for bookmarks or open tabs from KRunner.

There is already existing extension for Chrome that implements these features - plasma-browser-integration that can be used as a base for the Falkon extension.

Expected results: Falkon C++ extension and additional helpers improves the integration with Plasma desktop.

Knowledge Prerequisite: C++/Qt, JavaScript basics

Mentor: David Rosca ([email protected], IRC: nowrep on #falkon)

Firefox Sync

Brief explanation: Firefox Sync is an open API for synchronization of browser data between multiple instances. Falkon doesn't currently have support for any synchronization at all. Instead of creating in-house solution, it would be best to use some existing solution, which Firefox Sync appears to be a great candidate.

Firefox Sync is not exclusive to Firefox browser, it was already implemented for example in Gnome Epiphany browser (https://github.com/GNOME/epiphany/tree/master/lib/sync).

Expected results: Falkon is able to sync bookmarks, passwords, sessions ... over Firefox Sync API.

Knowledge Prerequisite: C++/Qt

Mentor: David Rosca ([email protected], IRC: nowrep on #falkon)

GCompris

GCompris is a high quality educational software suite, including a large number of activities for children aged 2 to 10. Contact the GCompris team.

Project: Finishing the port of the major activities for version 1.0

Brief explanation: Originally written in Gtk+ the development team started to rewrite it from scratch in Qt Quick and almost finished the port.

Expected results: The aim of this year is to work on the most important activities that we are missing to have a complete 1.0, mostly the analog electricity one (https://phabricator.kde.org/T5954, other activities can be proposed too, for example, we lack activities to learn about biology). First phase is to check how the Gtk+ version was working, what could be improved and then create a proposal with a timeline explaining what you expect to do and the time estimation. It does not need to be a simple clone, improvements should be done when possible.

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: Provide a timeline in your application. If you haven't contributed yet please read http://gcompris.net/wiki/GSOC_newcomers, 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: Aman Kumar Gupta (IRC: gupta2140[m]), Emmanuel Charruau (IRC: allon), Johnny Jazeix (IRC: JohnnyJ), Timothée Giet (IRC: Animtim)

Project: One step closer to version 1.0

Brief explanation: we had some remarks that the difficulty in an activity can increase too much and target different ages in the same levels. The aim of this project is to add a granularity on the datasets so the child can better target what to learn.

Expected results: The aim of this project is to update activities to be able to use json files as datasets so we can have multiple datasets (each targeting a different learning goal) for the same activity.

You need to choose activities that need this kind of datasets and update their code to use multiple datasets.

A discussion is opened in https://phabricator.kde.org/T10211 to better know what we want and how to do it (WIP).

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

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: Aman Kumar Gupta (IRC: gupta2140[m]), Emmanuel Charruau (IRC: allon), Johnny Jazeix (IRC: JohnnyJ), Timothée Giet (IRC: Animtim)

KDE Connect

KDE Connect is a project that enables all your devices to communicate with each other.

KDE Connect for Windows port

We want to improve the integration of KDE Connect with the Windows system. As of now, KDE Connect builds on Windows (using Craft) and some plugins have been ported, but it's still unstable and incomplete.

This project should aim to:

Implement all the missing plugins
Provide full integration with the OS:
- Send-to integration from the right-click menu,
- Make the notifications appear in the Windows 10 notifications bar, etc.
Improve existing documentation for how to compile (and use) KDE Connect on Windows
- It would also be great if we had the option to use mingw as the compiler instead of depending on the Visual Studio compiler

By the end of the project, we should have a releaseable installer for KDE Connect on Windows and/or KDE Connect published on the Windows app store.

Areas of knowledge: Experience writing Windows applications, C++ and Qt5 is required.

Mentor: Simon Redman ([email protected])

Feel free to reach out to the rest of the team on the kdeconnect mailing list, Telegram, or on #kdeconnect on Freenode

KDE Connect bluetooth backend

KDE Connect works using a LAN/WLAN connection, but this isn't available everywhere. Examples are offices, schools, university or in public transport. Thus, KDE Connect has an alternative bluetooth backend, but it still needs a lot of work.

The goal of this project is to make the bluetooth backend of KDE Connect production-ready. Examples include:

Make pairing devices in KDE Connect work over bluetooth
Find a solution for file-browsing over bluetooth
Investigate multi-device connectivity
Lots of bluetooth debugging

By the end of the project, we should have a fully-working bluetooth backend, good enough to release to all users.

Areas of knowledge: Experience in C++, Qt5 and Java development is required. Knowledge of Android development is preferred.

Mentor: Matthijs Tijink ([email protected])

Feel free to reach out to the rest of the team on the kdeconnect mailing list, Telegram, or on #kdeconnect on Freenode

KDE neon

KDE neon compiles KDE software to make it available pronto.

Project: ISO Image Writer

ISO Image Writer copies ISO images onto USB drives. It needs code tidied up and builds made for Snap, FlatPak, Windows, Mac and good old Linux packages. Design to implement

Expected Results: Installable packages

Knowledge Prerequisite:

C++, Qt, Build systems, multi-platform

Mentor:

Level Medium

Mentor: Jonathan Riddell (IRC: Riddell)

Kdenlive

Kdenlive is a KDE-application for professional 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.

Project: Evolving Titler tool

Brief Explanation: Kdenlive titler tool allows to draw texts and images to composite over videos.

Current code is using XML description, drawn by our "kdenlivetitle" MLT module, using old QPainter engine. This engines has limitations that blocks interesting features. Few years ago, an upstream module appeared in MLT, named "WebVfx", which uses QML to do similar things with much more flexibility.

We would like to be able to load current XML titles and convert them automatically to QML format, and generate QML from our current GUI. Then the GUI could evolve to integrate new features, in accordance to our community requests & design group recommendations.

Expected Results: A titler using QML backend

Knowledge Prerequisite:

C++, QML

Level Medium

Mentor: Vincent Pinon (IRC: vpinon)

KDE Partition Manager

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.

https://webchat.kde.org/#/room/#partitionmanager:kde.org

Project: Port authentication to Polkit-qt

Brief Explanation: KDE Partition Manager was recently ported to KAuth (which is Tier 2 KDE Framework library). This means that instead of running the whole GUI as root, KDE Partition Manager runs as a normal user, starts a small (non-GUI) helper application which runs as root and executes privileged tasks.

KAuth itself was not sufficient for this task, so we built a small protocol on top of KAuth. Usually, programs that use KAuth, start a helper, it does its job and exists. In KDE Partition Manager, helper persists, and communicates with KDE Partition Manager using a fairly simple DBus protocol over which GUI application can request two things:

execute some external program, like sfdisk, btrfs, etc...
Copy block of data (partition) to another location).

However, KAuth library itself is a layer built on top of Polkit-Qt (which is a small wrapper around Polkit).

The proposal for this project is to port away from KAuth and run our custom protocol between helper and GUI application directly on top of Polkit-Qt.

Knowledge Prerequisite:

C++ and basic knowledge of Qt

You don't need experience of using DBus, you can pick this up during the project.

Mentors: Andrius Štikonas (IRC: stikonas), Caio Jordão Carvalho (IRC: cjlcarvalho)

Project: Finish mdraid and implement dmraid support

Brief Explanation: KDE Partition Manager got a mdraid (Software RAID) support during the last Google Summer of Code as you can see in the raid-support branch. It is working with a good number of functionalities such as the display of RAID devices and the manipulation of them. Most of this work is completed, but there are some implementations and fixes to do, solve some udev bugs and include the implementation for resizing mdraid volumes.

There is another type of RAID available for Linux systems, which is dmraid (FakeRAID). It works along the device mapper to discover and manipulate ATA RAID devices created by controllers BIOS. Our goal in this project is to offer some basic functionalities for it, such as displaying, creating, erasing and manipulating partitions inside of these volumes.

The proposal for this project is to finish mdraid support and implement initial dmraid support.

Knowledge Prerequisite:

C++ and basic knowledge of Qt

Mentors: Andrius Štikonas (IRC: stikonas), Caio Jordão Carvalho (IRC: cjlcarvalho)

KDevelop

KDevelop is a cross-platform IDE for C, C++, Python, QML/JavaScript and PHP. Contact the KDevelop team.

Ansible plugin for KDevelop

Brief explanation: Ansible is an open-source tool to automate server configuration management, application deployment, etc. We would like a KDevelop plugin that treats Ansible YAML files as a programming language, and provides, for example, code completion for Ansible "modules" and their parameters.

Many other features could be concieved for such a plugin, such as inline warning of common errors in the YAML code, helper to create a new role, language support for inventory files, editing files encrypted with ansible-vault, embedded Ansible documentation, etc. Your proposal should say what concrete features you plan to implement.

Knowledge Prerequisite: C++, Qt, basic familiarity with KDevelop as a user. Ideally experience with Ansible too.

Mentor: Nicolás Alvarez ([email protected])

Krita

Krita: digital painting for artists. It supports creating images from scratch from beginning 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 patches 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: Integrating the MyPaint Brush Engine

Brief Explanation: The MyPaint brush engine has been separated from the MyPaint application and has been completely rewritten. Artists still like the mypaint brush engine a lot and it would be great to have the engine integrated in Krita as a new brush engine. Libmypaint can be found here: https://github.com/mypaint/libmypaint and the brush set here: https://github.com/mypaint/mypaint-brushes . The first goal is to integreate libmypaint in a Krita brushengine and make it load the brushes. The second goal is to expose the MyPaint brush options in Krita's brush editor and allow the modification and creation of MyPaint brushes in Krita. GIMP is an example of an application that has already integrated the MyPaint brush engine.

Expected Results:

Artists should be able to effectively paint with MyPaint brushes in Krita.

Knowledge Prerequisite:

C, C++, Qt, Krita

Mentor: Boudewijn Rempt (IRC: boud)

Project: Supporting Vertical Text and SVG2 Text in the Text Shape

Brief Explanation: Krita's Text Shape was rewritten for Krita 4.0. It is now SVG based, instead of ODF. There are many things lacking, though. The original goal was to support SVG2. Currently the text shape only supports SVG1. There is no automatic wordwrap and vertical text (e.g. Chinese and Japanese) is not supported either. The goal of this project is to support wordwrap and vertical text layout. Other improvements to the text shape can be proposed as well. The level of this project is advanced.

Expected Results:

Artists should be able to create and edit vertical text. Text shapes should be able to automatically wrap text to the bounding box.

Knowledge Prerequisite:

C, C++, Qt, Krita, SVG, Typography, Text Layout

Level Advanced

Mentor: Boudewijn Rempt (IRC: boud)

Project: Add New Fill Layer Types

Brief Explanation: Fill layers are layers that automatically generate content. Krita currently has two types of fill layers: Color and Pattern. There used to be another type that generated content dynamically using the OpenShiva scripting language. However, that language hasn't been maintained for a long time. The goal of this project is to add a new dynamic fill layer types that could fill an area with different effects such as perlin and other types of noise, clouds, hatching, fractals.

Expected Results:

Several new fill layer types that allow the user to add dynamically generated content as a layer in the layer stack

Knowledge Prerequisite:

C, C++, Qt, Krita

Level Medium

Mentor: Boudewijn Rempt (IRC: boud)

Project: Port Krita to Android OR iOS

Brief Explanation: Krita is currently only available on Windows, macOS and Linux. The goal of this project is to port the desktop version of Krita to one mobile operating system, either Android or iOS. This involves making sure all (or a viable subset of) Krita's dependencies are available on the target platform, as well as Krita itself.

Expected Results:

A build of Krita that starts on either mobile OS and shows an image. Further integration with either mobile OS would be nice, but is an extra. Furthermore, the build system and build scripts need to be documented, complete and maintainable.

Knowledge Prerequisite:

C, C++, Qt, Krita, CMake, Android or iOS. You also need to have access to test hardware.

Level Advanced

Mentor: Boudewijn Rempt (IRC: boud) Jayaditya Gupta (IRC: nightmare_unreal/jayssj11)

Project: Improve Krita for Touch Systems

Brief Explanation: Krita Gemini/Krita Sketch were version of Krita based on QtQuick 1 that provided a decent touch-only experience. Because of the technical limitations of QtQuick 2, the approach used in Gemini and Sketch is no longer viable. Since Krita 4, there is a QtQuick2 based touch docker that mimics the button bar found on some wacom devices. This is not configurable, and quite limited. This project involves working with Krita's UX designers and users to define a new approach to supporting touch devices, then implementing that support.

Expected Results:

Artists should be able to work with Krita on a touch-only device such as a Surface Pro or Wacom Mobile Studio without wanting to chop their devices in two.

Knowledge Prerequisite:

C, C++, Qt, Krita

Level Medium

Mentor: Boudewijn Rempt (IRC: boud)

Project: SVG Mesh Gradients

Brief Explanation: Even though Mesh Gradients are not officially part of the truncated SVG2 specification anymore, having a second implementation next to Inkscape would help improving the standard. Plus, mesh gradients are very useful for artists. This project entails implementing a new gradient type. Whether this should be based on QGradient or not is up for discussion. The gradients should render exactly the same as in inkscape. See https://svgwg.org/svg-next/pservers.html#MeshGradientElement.

Expected Results:

A new gradient type, UI to create and edit these gradients and apply them. Gradients should work both on vector objects as well as on paint layers.

Knowledge Prerequisite:

C, C++, Qt, Krita, SVG, Inkscape

Level Advanced

Mentor: Boudewijn Rempt (IRC: boud)

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 opacity, 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

Level Advanced

Mentor: Jouni Pentikainen (tyyppi on IRC)

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 revamped and exciting shapes brush

Knowledge Prerequisite:

C++, Qt, Krita

Level Medium

Mentor: Boudewijn Rempt (IRC: boud)

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 an 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 support 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: FITSViewer & Photometry Improvements

Brief explanation: The FITSViewer is used to display FITS images as captured by cameras or opened by the user. It supports 8, 16, 32, and 64bit formats with either a single channel (Mono or Bayer) or RGB cube. The goal for this project is to provide efficient and intuitive controls for:

Histogram Adjustments: Controls for Shadow, Midtones, and Highlights. White / Black points controls.
Noise Calculation: Calculate the overall Signal-to-Noise (SNR) radio for the overall image, or a specific subframe of the image.
Sky Glow Computation: Estimation of Sky Glow component in image of various exposures. Each captured image is affected by multiple sources of noise, only of which is the sky glow which in turn is affected by the atmosphere, pollution, and artificial sources (e.g. light). The objective is to propose to the user the optimum exposure time given the sky glow contribution to the image.
Mask Overlay: Ability to select custom mask over stars to aid in focusing and photometry.
Photometry: KStars includes SEP which can be used to extract sources from stellar images and also performs aperture photometry. A new tool should be developed to aid the users to perform photometric work with the images including reduction of images (darks & flats) with various optimization/algorithmic settings. Additionally, the tool provides means for aperture photometry calculations as well.

Since FITSViews typically deals with very high-resolution images, such calculations can be very computationally expensive. It is expected that a very efficient multi-threaded code to be developed to take advantage of all the available cores on the system and any hardware or instruction set optimizations to achieve the smoothest user experience. Expected results:

Improved Histogram Tool.
New controls for histogram.
SNR, Sky Glow, and Photometry calculations.
Photometric reductions. Aperture photometry.

Knowledge Prerequisite: C++, Qt, Threading, Data Structures

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: Jasem Mutlaq (Matrix: Jasem)

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. Labplot is part of the KDE Edu team.

Contact KDE-Edu

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 definition of the data sources should be made available on store.kde.org.

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

Knowledge Prerequisite: C++, Qt

Mentor: Fábián Kristóf

Project: Statistical analysis

Currently LabPlot has only basic support for statistical data analysis by providing some basic measures of descriptive statistics in the spreadsheet. The goal of the project is to add more statistics relevant features (hypothesis tests, cluster analysis, ets.) to LabPlot.

Expected results:

evaluate available statistical open-source libraries which can be used for this project
determine a reasonable set of features and algorithms that can be added to LabPlot, compare here with other similar projects, and implement them
for the visualization of results of statistical calculations, implement new kind of reports for this, comparable to other similar projects

Knowledge Prerequisite: C++, Qt, basic statistics knowledge

Mentor: Stefan Gerlach, Alexander Semke

Okular

Okular is a universal document viewer developed by KDE. Okular works on multiple platforms, including but not limited to Linux, Windows, Mac OS X, *BSD. Contact the Okular developers.

Project: Support animated PDF

Brief explanation: PDF files can support animation via JavaScript. This is one feature that is regularly requested by users and would be nice supporting it in Okular. Knowledge Prerequisite: C++, Qt

Mentor: Albert Astals Cid [email protected]

Application guide:

Project: Add support for showing and adding replies to sticky notes

Brief explanation: PDF files can contain replies to certain annotations. In this project, you would need to add support to Okular and possibly to 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

Project: Improve custom stamp annotation handling

Brief explanation: Okular does display stamp annotations, but the support is somewhat incomplete. This particularly shows when trying to use stamp annotations with a custom image. For example, such annotations can be added in Okular, but they cannot be saved to the pdf file in a way that any other pdf viewer can read. Also, they will not appear on print-outs.

The underlying reason for this is that Okular renders these stamps itself, rather than relying on the poppler library, which does all other pdf rendering. Goal of this project is therefore to teach poppler how to render stamp annotations, and then make Okular use that new functionality. More details can be found in the bug report [0].

[0] https://bugs.kde.org/show_bug.cgi?id=383651

Expected results: Poppler should render stamp annotations. Annotations should be printable from Okular. Custom stamps inserted via the Okular GUI should be visible in other pdf readers.

Knowledge prerequisite: C++, and a bit about the pdf format.

Project: Annotation improvements

Brief explanation: Okular supports convenient editing of pdf annotations, but quite a number of paper-cut bugs are known. Examples are [0,1,2], but many more can be found in the bugtracker. Goal of this project is to fix as many of these bugs as possible, which should improve the Okular user experience greatly.

[0] https://bugs.kde.org/show_bug.cgi?id=275371

[1] https://bugs.freedesktop.org/show_bug.cgi?id=102635

[2] https://bugs.freedesktop.org/show_bug.cgi?id=52010

Expected results: Lots of annotation-related bugs fixed. Annotation rendering and manipulation should be more enjoyable.

Knowledge prerequisite: C++ and Qt, and a bit about the pdf format

Plasma Mobile

Plasma Mobile is KDE's software stack for mobile devices that includes Plasma phone components, Kirigami and a set of mobile-friendly applications.

SMS App

Plasma Mobile currently does not have a functional SMS app. One approach to this would be extending the SMS app that is currently developed for KDE Connect to have a Plasma Mobile backend.

This includes: - Develop an approach to make the app support multiple backends - Develop a backend for the Plasma Mobile SMS stack (ofono) - Possibly improvements to the Plasma Mobile SMS stack - Possibly improvements to the SMS app UX

Goal is to be able to communicate via SMS on a Plasma mobile phone with all basic features (sending, receiving SMS, browsing through conversations).

This requires access to a Plasma mobile enabled phone, preferably the Nexus 5X. Second-hand phones are available at very low prices.

Areas of knowledge: Basic understanding of C++ and Qt5.

Mentors: Simon Redman and Nicolas Fella for KDE Connect specific things, Bhushan Shah for Plasma Mobile things. Get in touch with us on #kdeconnect on freenode or the Plasma Mobile Matrix channel

Nextcloud integration

Plasma Mobile offers the accounts integration, which allows to add various online accounts like, Google, Nextcloud and provides very basic service which allows copying contacts from the Nextcloud calender. We would like to offer fully integrated solution for Nextcloud in Plasma Mobile.

This includes: - System settings module for adding and configuring the Nextcloud account - Syncing of contacts, calenders from the nextcloud (ideally should support bi-directional sync) - Syncing of the files/documents/pictures.

End goal is user being able to add nextcloud account easily and use the data shared on nextcloud instance.

Areas of knowledge: Basic understanding of C++, Qt5, and QML.

Mentors: Bhushan Shah, Get in touch with us on the Plasma Mobile Matrix channel

Purpose

The Purpose framework offers the possibility to create integrate services and actions on any application without having to implement them specifically. Purpose will offer them mechanisms to list the different alternatives to execute given the requested action type and will facilitate components so that all the plugins can receive all the information they need.

Barcode scanning infrastructure

Purpose enables application developers to use features without implementing them themselves. It offers multiple alternatives to achieve a goal. Right now it supports sharing files and URLs.

An interesting use case for it would be scanning barcodes. An application developer that wants to scan a barcode would ask Purpose for it. Purpose would offer multiple ways of doing it, e.g. from a local file, from the local camera or from a via KDE Connect connected phone. Purpose would then return the data to the application.

Goal of this task is to have a framework for scanning barcodes as well as multiple implementations. This consists of: - Adding a new Plugin type to Purpose - A import from file backend - A local camera backend - A KDE Connect backend - One or more applications using it, e.g. Itinerary or a barcode scan app for Plasma Mobile

Areas of knowledge: Basic understanding of C++ and Qt5 is required. Experience with Java/Android for the KDE Connect backend is beneficial.

Mentor: Nicolas Fella (nicofee) for KDE Connect parts. Aleix Pol (apol) for Purpose parts. Volker Krause (vkrause) for zxing parts. Devel mail list.

KWin

Clipboard Management Wayland protocol

Currently on Wayland functionality like Klipper and clipboard sync via KDE Connect is not working because the programm cannot access the clipboard in the required way. A special wayland protocol for that will be needed. The wl-roots project has a [proposal https://github.com/swaywm/wlr-protocols/blob/master/unstable/wlr-data-control-unstable-v1.xml] for this. This GSoC project is about implementing support for it in KWin and making use of it in Klipper and KDE Connect.

Areas of knowledge: Basic understanding of C++, Knowing what Wayland is. Mentor: Roman Gilg (romangg), Nicolas Fella (nicofee)

Wayland graphical tablet input support

Brief Explanation: Tablets are very different from mice, they have a lot more information about their current state and events. As such there are separate protocols for passing these events from raw hardware to the client. We need to add:

* A protocol in kwayland to wrap the low level protocol
* support in KWin to map libinput to sending wayland events to the right clients.
* support in Qt's wayland client code to map wayland to Qt events that applications can use

(this will mean collaborating not just within KDE code but also Qt)

Expected results: Working tablet support in all applications within a kwin wayland session.

Knowledge Prerequisite: C++, Qt5,

Mentor: David Edmundson ([email protected]), Vlad Zagorodniy (zzag)