Difference between revisions of "Projects/Summer of Code/2009/Ideas"

(add project)
m (typos)
Line 378: Line 378:
'''Knowledge prerequisite:'''
'''Knowledge prerequisite:'''
C++ (less KDE knowledge requires for this, but strong c++ skills required)
C++ (less KDE knowledge required for this, but strong c++ skills needed)

Revision as of 00:26, 7 March 2009


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

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.



Website - Mailing list - IRC channel: #plasma on Freenode.

Project: Network Enabling Plasma::Service

Brief explanation: The Service should be able to parse WSDL files and let Plasmoids connect to the described Webservices as well as optionally announce itself to the local network over uPnp and/or zeroconf. Finally, a Service that announces itself and can send a widget over the wire to another Plasma instance would complete this project.

Project: Simple Media Center components

Brief explanation: Plasma could offer a Media center mode, where features a really simple ui to browse media files and plasmoids that shows the actual media. All should be operable with mouse, keyboard or a simple remote control. the work could consist in building the whole thing or just writing a plasmoid able to browse media files, that is the most important missing part. Mockups for it by Nuno Pinheiro can be seen here and here

Expected results: An applet to browse and thumbnail media files, like the first mockup and control the actual media viewing applets, like the media player applet or the picture frame applet. At this stage the functionality will be really minimum

Knowledge prerequisite: Knowledge of C++ and some familiarity with Qt especially QGraphicsView related classes.

Mentor: Marco Martin (notmart a gmail dot org), or other Plasma developers. Contact at [email protected] or #plasma on freenode.

Project: Plasmate

Brief explanation: PlasMate is an application that gives people a way to start creating scripted plasmoids without worrying about anything except making their bits. It hides the whole metadata.desktop thing, the package layout details, making a Plasmoid package (aka "zipping up the directory"), uploading content and version control system.

Expected results: Working application that one can do the tasks described above, making it easy to create and distribute a scripted plasmoid.

Knowledge prerequisite: Knowledge of C++ and familiarity with Qt (QWidgets and QGraphicsView related classes).

Mentor: Artur Duque de Souza (morpheuz a gmail dot org), or other Plasma developers. Contact at [email protected] or #plasma on freenode.

Project: Qt Kinetic + Plasma

Brief explanation: A layer over Qt Kinetic to provide a standardized set of "out of the box" animations and bring them into libplasma. The work will be done with the Plasma developers to make this API as efficient as possible. The work will be based on Kinetic, the next framework for animations in Qt.

Expected results: We can kill Plasma::Animator class. The goal is to bring fancy effects/animations in Plasma to have one of the best desktop ever.

Knowledge prerequisite: Knowledge of C++, familiarity with QGraphicsView related classes and some familiarity with animations bits.

Mentor: Alexis Ménard (alexis.menard at nokia dot com) or Artur Duque de Souza (morpheuz a gmail dot org). Contact at [email protected] or #plasma on freenode.

Project: Eduactional layout

Brief explanation: A set of Containments and Plasmoids specifically designed for primary school students.

Expected results: A simplified panel containment that contains basic launchers and user feedback for the student, a widget that allows teachers to provide context-specific sets of applications and documents to the student (context being a combination of the student logged in and the current class subject), a widget that provides some basic teacher->student communication and status (e.g. what the current assignment is, how long the student has been logged in, etc) and optionally some widgets that work with KDE edu apps.

Knowledge prerequisite: Knowledge of C++.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: Desktop dock

Brief explanation: A MacOS style dock containment.

Expected results: A containment that provides a similar user experience to the MacOS dock: application launchers that are also task bar entries when the application is active and a separate area for widgets such as the trash, battery, etc.

Knowledge prerequisite: Knowledge of C++.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: Kdm frontend using plasma

Brief explanation: A log-in screen layout manager for KDM that uses libplasma.

Expected results: A KDM screen that is rendered completely using Plasma. This means both using libplasma in KDM for the log in screen as well as writing Plasmoids for entering the user name and password, listing users, session switching, etc. Some of these widgets already exist for the desktop shell, so in some cases this will be simply integrating existing Plasmoids, but in other cases will mean writing new ones from the ground up.

Knowledge prerequisite: Knowledge of C++.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: Raptor

Brief explanation: Raptor aims to deliver a new kind of launch menu system for KDE. It is designed with usability and beauty in mind. Raptor-Menu does not try to be the final answer to the menu question, instead aspires to be the best answer we can give, merging many ideas form modern desktop launch menus.

Expected results: http://www.raptor-menu.org/

Knowledge prerequisite: Knowledge of C++.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: New Widget Explorer

Brief explanation: A new widget explorer that supports both our own widgets as well as others more seamlessly.

Expected results: A usable and pretty browser for widgets that allows a user to see an icon or snapshot of the widget, select a widget to be placed in a containment, search for a widget based on name/description, sort the widgets into categories, rate widgets and provide ways to launch the online browsers and installers for both native Plasmoids as well as third party tools such as Google Gadgets (which is already supported in the Package class). All the required support functionality already exists, this project is really about creating a beautiful and dynamic user interface for looking through a widget catalog that looks "Plasma".

Knowledge prerequisite: Knowledge of C++.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: D-Bus Interface

Brief explanation: A comprehensive set of D-Bus interfaces for the plasma-desktop Plasma shell.

Expected results: The D-Bus interface must provide access to the Corona (DestkopCorona class), which in turn will list all existing Containments and allow Containments to be added, removed, saved, etc.

A D-Bus interface for each existing Containment will be made available as well, which will provide a standard set of tools including listing, adding and removing widgets as well as positioning and sizing for PanelContaiments. Ways to control the wallpaper, if any, will also be provided in the per-Containment D-Bus interface.

In turn, a D-Bus interface for each widget representing its available contextual actions will be provided dynamically upon request.

Finally, the application D-Bus interface for things such as locking/unlocking widgets will be designed and implemented.

The result will be a Plasma that is fully accessible via D-Bus.

Knowledge prerequisite: Knowledge of C++.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: Security

Brief explanation: A set of methods to define the existing security state of the Plasma application, the security requirements of individual widgets, mechanisms to respect those two sets of information and cryptographic signing of Plasmoid packages.

Expected results: A set of functionality descriptions will be enumerated (e.g. "Network access", "Local file system access", etc.). Individual widgets will advertise which of these functionality sets they require.

The plasma-overlay shell (used on the screensaver) will have code added to it to respect these settings and not run widgets that advertise they need things that aren't safe to provide on a screensaver (due to it being locked to prevent others from accessing the system).

The plasma-desktop shell will gain the ability to be put into various lock down states which will map to different sets of functionality. Part of this project will be enumerate the various states, but that list must include "only load trusted widgets", "no external access", "no local file system access".

The JavaScript engine will provide methods for each of the functionality sets (e.g. a set of functions to access local files) which will be exported or not based on the current Security state. This implies providing a security state to the Corona which can then be passed on down to Applets and AppletScripts.

Finally, GPG signing of Plasmoid packages will be implemented along with a way of checking the validity of these at runtime.

Knowledge prerequisite: Knowledge of C++ and some experience with security.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.

Project: Telepathy Integration

See here for more project details.

Project: Containment saving

Brief explanation: The user has a system with limited resources, and lots of activities. It must be possible to close the ones that haven't been used recently, but not delete them forever. The user has a really cool setup, and a friend wants to get one of his/her activities.

Expected results: The idea is to save out the containment's config to another file (in $APPDATA or something for use case 1) and remove it, then when the user wants to load a saved containment we give them a list of the saved containments (plus an option to load from any file), then pull in the one they choose. If they choose one from the list then we remove that file so that they don't get multiple copies of the same activity.

Knowledge prerequisite: Knowledge of C++ and Qt.

Mentor: Plasma team. Contact at [email protected] or #plasma on freenode.


A KDE music manager and player.

Website - Mailing list - IRC channel: #amarok on Freenode.

Project: DLNA/UPnP Support

Brief explanation: Using the UPnP protocol users can, for example, share music from their Vista computer to a PS3. Amarok lacks any sort of UPnP support. Being able to act as a client or possibly a UPnP media server would be useful. In addition to that controlling a UPnP Media Renderer from within Amarok is possible with framework support.

The Coherence server would likely be used since it is also intended to be used by a KIO slave.

Expected results:

  • Using the Amarok Collection framework, create a plugin which allows Amarok to browse, search and play music off of a UPnP share. Playing music may use the UPnP KIO-slave, but more advanced functionality requires Amarok to handle this directly.
  • Allow Amarok to share it's collection with other devices or control other devices via UPnP. This is secondary priority but it may be pretty easy with Coherence.
  • Control UPnP Media Renderers (DMR: Digital Media Renderer device class in DLNA) from within Amarok.

Material Prerequisite: Some UPnP devices or computers to test with. Good excuse to buy a PS3. If you live in Europe a Philips Streamium DMR can be borrowed.

Knowledge Prerequisite: C++ and Qt. Coherence uses Python and D-Bus but doesn't need to be hacked on in the scope of this project.

And of course, understanding of UPnP networking and devices wouldn't hurt!

Mentor: Stecchino (bart.cerneels at kde dot org)

Project: New meta-applets for the Context View

Brief Explanation: The Context View (CV) is currently used to display multiple applets that expose various information. However, due to the fact that each applet displays a certain type of information from one data source, there is significant amount of wasted space, and it is hard to show much more than 3 different pieces of data at once.

Meta-Applets are large applets that integrate date from multiple data sources in order to display more semantically related information coherently and efficiently. This could mean, for example, an applet that brings together lyrics, artist info, upcoming concerts, and related songs/artists.

More info is available here on the amarok wiki

Expected Results: Two or three (to be discussed with mentor in application writing process) applets that elegantly execute the ideas discussed above.

Knowledge prerequisite: Knowledge of C++ is required, and some familiarity with Qt is helpful (especially QGraphicsView) but not necessary.

Mentor: Leo Franchi (lfranchi AAAT kde DT org), or other Amarok developers. Contact at [email protected] or #amarok on freenode.

Project: Code regression test suite, implemented with QtScript

Brief explanation: Amarok currently has no automatic code regression testing ("unit testing") in place at all. We very much need such a system in place (for as many components as possible), as we sometimes accidentally break certain components of the program by extending the code.

Expected results: Code regression test suite for Amarok 2, implemented as one "Amarok-Script" (JavaScript), and internally split into multiple separate files and components, so that it would be possible to run arbitray tests (or the full suite) with very little effort, and no compiling, at any time. A requirement would also be testing of the collection scanning code (with test case collections), and testing of GUI correctness with the QTest library.

Also see: http://amarok.kde.org/wiki/Development/Scripting_HowTo_2.0

A plus would be the generation of suitable statistics (possibly with document export), and possibly a visual representation of the data.

Knowledge Prerequisite: C++, Qt, KDE-Libs, QtScript (JavaScript), SVN, git, code testing.


Contact the amarok mailing list or ask in our IRC channel #amarok

Project: Multilevel playlist sorting and sorting GUI

Brief explanation: In Amarok 2.1, the layout of the playlist will be very configurable, being able to show as much or as little information about each track as each user might wish. Currently however, it is lacking an advanced system for sorting in the playlist, something that many users comming from Amarok 1 are missing. While simple sorting is relatively easy to do (and has already been partly implemented) we would like to aim a bit higher with Amarok 2.

Expected results: A proxy model allowing the tracks in the playlist to be sorted using an arbitrary number of "layered" sort criteria. for instance, a sort setup could be "artist-album-tracknumber" This would sort all tracks by artist, then sort the tracks from each artist by album, and finally the tracks from each album based on track number. Once this model is working, a GUI is needed for making this functionality easilly avaialble to the user. Ideally this gui should tie in well with the playlist layout and search/filter stuff. Also, all track navigators (the classes that determines the order of playback, such as normal, random, random album and so on) need to be updated to use and work correctly with the new proxy model.

Knowledge Prerequisite: C++, Qt, KDE-Libs, SVN/git.

Mentor: Nikolaj Hald Nielsen <[email protected]> or contact the amarok mailing list or ask in our IRC channel #amarok

Project: Playlist and Collection synchronization

Brief explanation: Mediadevices and services can add tracks and playlists to Amarok. Synchronization would automatically copy over tracks between the main Amarok Collection and devices or services or even between each other, either for a single playlist or the complete collection. An algorithm needs to be implemented that does this automatically in a fast and efficient way with minimal intervention needed by the user.

Expected results: Playlists set up on both the local collection and a portable mediaplayer will get synchronized the moment the player is connected.

Knowledge Prerequisite: C++, Qt, KDE-Libs, SVN/git.

Mentor: Bart Cerneels <bart.cerneels at kde dot org> or contact the amarok mailing list or ask in our IRC channel #amarok

Project: Mass Tagging

Brief Explanation: Many Amarok users will remember the support for Musicbrainz in the 1.x series. These intrepid users might also remember how it worked approximately 50% of the time, sometimes deciding on a whim that divulging the secrets of the correct tags would be too much to share. In Amarok 2 we have decided to skip integration with Musicbrainz as a result of our problems using the library etc.

Luckily, Last.fm provides a fingerprinting service, similar to musicbrainz, that will allow us to look up track data. However, the real challenge for the summer is not writing the code to allow Amarok to tag individual tracks, but rather how to present a mass-tagging interface in a aesthetically pleasing and usable way.

This project involves designing and implementing a UI for mass-tagging of tracks, and requires the student to interact with usability experts and visual designers as well.

Expected Results: Mass-tagging functionality in Amarok using data from Last.fm

Knowledge prerequisite: C++, Qt. KDELibs knowledge helpful, but not required.

Mentor: Leo Franchi (lfranchi AAAT kde DT org), or other Amarok developers. Contact at [email protected] or #amarok on freenode.

Project: Improved Media Device Support

Brief Explanation: Improve the media device support in Amarok, especially universal mass storage devices.

Expected Results:

Knowledge prerequisite:

Mentor: One of several Amarok developers. Contact at [email protected] or #amarok on freenode.

Project: Improved Various Artist Handling

Brief Explanation: Improve the handling of albums with several artists in Amarok.

The Various Artists / Compilations support in Amarok 2 is far from at the level at which it was in Amarok 1.x, and really is mostly just lacking completely. It desperately needs a student who is passionate about various artist support and wishes to dedicate his/her summer to fixing it :)

With regard to the technical details, the potential student is recommended to look at the "Various Artists in Amarok 2.0" thread here: december mailing list archives to craft some sort of concrete proposal.

This is definitely a project that would involve deep changes in Amarok, so a serious and dedicated student is important. Also, close discussion with the Amarok devs on [email protected] during the proposal process will help to outline what is reasonable and desirable for a summer of work.

Expected Results: Elegant and subtle handling of Various Artists support in Amarok 2.x

Knowledge prerequisite: C++ (less KDE knowledge required for this, but strong c++ skills needed)

Mentor: One of several Amarok developers. Contact at [email protected] or #amarok on freenode.


Abstraction library for sound and video support. Used by KDE notifications, Amarok, Dragon Player and Qt Software.

Website - Mailing list - IRC channel: #phonon on Freenode.

Project: Analyzer Support

Brief explanation: Applications such as Amarok and Dragon Player cannot have an analyzer or visualizations since they use Phonon which does not yet have the functionality to do it. The analyzer is the little bar graph thing which bounces around while music is playing. Users like it as its pretty and gives them a visual indication of their music playing.

Expected results: As this project is working on extending a library, it has three parts: the Phonon library itself, a Phonon backend, and an application. The Phonon library would need the new API calls. At least phonon-xine and preferably 1 or 2 other Phonon backends must then implement the new API. An application like Amarok or Dragon Player should be used to demonstrate the use of the new API.

Knowledge Prerequisite: C++ and Qt. Experience with Xine or GStreamer is probably useful.

Mentor: Ian Monroe (contact on the Amarok mailing list) or possibly another Amarok or Phonon developer.


A desktop globe and map application. Also provides a map Qt Widget.

Website - Mailing list

Project: Satellite navigation

Brief explanation: Satellite navigation devices have become widely used and the quality of openstreetmap data is becoming high, with some cities completely mapped already. Providing satellite navigation would be a useful desktop app for many as well as adding appeal for the use of KDE in embedded devices.

It also opens the possibility to bringing many of the free software ideals to interaction with the real world such as collaborative/social POIs.

Expected results: The project would aim at getting a basic satellite navigation application running. The most basic features required would be getting the current location from a GPS device and providing route calculation to a destination.

The AndNav project (http://andnav.org) has already achieved something similar for Android so it could be a point of reference for how to use OpenStreetMap data to achieve this. A possible approach would be to use vector tiles from Cloudmade.

Knowledge Prerequisite: C++ and Qt. Experience with GPS devices under linux would be beneficial. Knowing java may also be of benefit in order to study the AndNav implementation.

Mentor: I (Alan Jones, skyphyr using gmail) am willing to mentor, but not having any GPS or Marble experience there is most likely somebody far more suited to undertake this role.

Comment from a Marble Project guy: Alan, please get in touch with the Marble Project. Our mailing list is [email protected] We'd like to support this project if a student is willing to do it.

Project: Add Time support to Marble

Brief explanation: Wouldn't it be great to be able to see the world at different times in Marble? Like having a slider which would give you the ability to browse through the time? Marble's internal datastructure is modelled after KML. But support for time-related tags is missing.

Expected results:

  • Having a GUI on the map and as a QWidget based dialog which allows people to "slide" through time.
  • Implementation of the KML <TimePrimitive> and <TimeSpan> tag: Creating the KML-handler and needed data classes for the GeoData parser.
  • Having a central "internal" clock which the current view would be based on.
  • Porting existing features (like the starry sky and the sun shading) over to the new class design.

Knowledge Prerequisite: C++ and Qt. Knowledge about KML is not necessary but would be appreciated.

Mentor: Torsten Rahn / Patrick Spendrin.


KStars is a Desktop Planetarium for KDE. It displays a map of the sky and provides a lot of tools to learn astronomy, or to calculate and predict astronomical phenomena. See [KStars Homepage] for more information.

Project: Community Integration for KStars

Project Information: KStars is a desktop planetarium program for KDE.

Brief explanation: Amateur Astronomy (which is one of the important use-cases of KStars) is typically done in communities. KStars permits users to save their own observing logs. It would be nicer if the user could share his observing logs with other users and see other observers' logs within KStars. It would also be nice if KStars had a map (using MarbleWidget) to display various Astronomy-related establishments (like amateur associations, observatories, research institutes). Another possible idea could be an observing report generator that would generate a report based on observing logs, and at the user's will, share it / post it on the internet.

Expected results: Implement some features that will make it easier for users to collaborate, as suggested above.

Knowledge Pre-Requisite: Required: C++. Prior knowledge of KIO_HTTP will help.

Mentor: Akarsh Simha <akarsh DOT simha AT kdemail DOT net>

Project: FITS Image Overlay on the sky map.

Project Information: KStars is a desktop planetarium program for KDE.

Brief explanation: It would be great if a FITS image could be overlayed on the sky map so that the field drawn by KStars could be compared with the field in the FITS image. This would be of great benefit to observational astronomers, astrophotographers and comet / asteroid observers. An extension would be to download a DSS image using KStars' already existing tool and map it onto the sky map. The support of shapes like ds9 region, annotations on the sky, etc. could also be added.

Expected results: Functionality to overlay a FITS image or a DSS image obtained through KStars on to the sky map.

Knowledge Pre-Requisite: Required: C++. Prior knowledge of the FITS format and cfitsio library will help.

Mentor: Akarsh Simha <akarsh DOT simha AT kdemail DOT net>

Project: Tools for Eclipses

Project Information: KStars is a desktop planetarium program for KDE. Currently, it can predict Solar Eclipses (using the Conjunctions tool), but cannot plot trajectory of shadows, or predict Lunar Eclipses.

Brief explanation: The project's primary goals are to include simulation and prediction (maybe using the existing Conjunction backend) of Lunar eclipses, and to create a tool to mark the trajectories of Solar and Lunar eclipse shadows on a map of the earth, including marking of totality, partial eclipse and annular eclipse. Something similar to this: [1]

Expected results: A complete set of tools to deal with eclipses.

Knowledge Pre-Requisite: C++

Mentor: Akarsh Simha <akarsh DOT simha AT kdemail DOT net>

Project: KStars: Prettyfication

Project Information: KStars is a desktop planetarium program for KDE. The display is interactive, but it could be made more beautiful.

Brief explanation: We often get good suggestions for making KStars look better. Choose any of the following ideas: realistic rendering of asteroids and comets (including tails!); texture-mapping of the sky (this would mostly allow a photorealistic Milky Way); texture-mapping of planets; realistic sky-lighting effects (i.e., sky is blue in the daytime, gets gradually darker and colorful at sunset). One could also think of using Qt-GL rendering optionally.

Expected results: Successful implementation of any of these ideas to make KStars more beautiful.

Knowledge Pre-Requisite: Required: C++.

Mentor: Akarsh Simha <akarsh DOT simha AT kdemail DOT net>

Project: Printable star charts

Project Information: KStars is a desktop planetarium program for KDE. It already has a print feature, but the printed chart could be much better.

Brief explanation: A printed star chart should at least include a legend explaining the symbols, and provide some information on the location of the user, the time and date, etc. The user would ideally be able to annotate the chart in various ways.

Expected results: Significant improvements to the printed star charts in KStars.

Knowledge Pre-Requisite: Basic programming skills, ability to quickly learn QPainter API.

Mentor: Akarsh Simha <akarsh DOT simha AT kdemail DOT net>

Project: Many Moons

Project Information: KStars is a desktop planetarium program for KDE. It currently includes Earth's moon and 4 of Jupiter's moons.

Brief explanation: Generalize the JupiterMoons class to encapsulate any planet's Moons. The project will require some research to identify a public source of orbital data for planetary moons, most likely from a NASA webpage.

Expected results: Implement moons for at least Mars, Jupiter, Saturn, and Pluto with the new system.

Knowledge Pre-Requisite: Required: C++. The project doesn't require much contact with Qt/KDE APIs, and the existing JupiterMoons class can be used as a template.

Mentor: Akarsh Simha <akarsh DOT simha AT kdemail DOT net>

Project: Support many catalogs

Project Information: KStars is a Desktop Planetarium for KDE. Currently KStars loads some star catalogs that are made available in a KStars native format.

Brief Explanation: KStars currently loads Tycho-2 and parts of USNO NOMAD catalog of stars. These catalogs are required to be in KStars' native format which uses the Hirearcheal Triangular Mesh to index regions in the sky. Popular star catalogs like USNO A organize stars and divide the sky into regions differently. Most users of astronomy software typically have one of these popular catalogs downloaded, and it would be great if KStars could support them somehow. While ability to read the non-native catalogs straight off is desirable, tools to convert these catalogs into KStars' native format would also help.

Expected Results: Implement support for at least the most popular catalogs like USNO-A2.0, Stellarium's Extra catalog, Cartes du Ciel's Tycho and Tycho-2 catalogs.

Knowledge Pre-Requisite: Required: C++. Ability to read documentation and quickly understand the existing code and ability to deal with binary files will help.


Project: Strigi integration

Project Information: The goal of this project is to integrate Strigi as backend behind the periodic table and the glossary (and possible other elements).

Brief explanation: The idea here is to have a GUI element that shows Strigi search results based on the element selected from the periodic table, or the item from the glossary, found on the users desktop. For element, this would include the elements name, and possible even the element symbol, if integration with last years Strigi-Chemistry GSoC project is achieved. For glossary items, a simple text search would suffice.

Another idea is to make it possible to querry like this: "Give me all molecules with a molecularweigth of 123u and at least one Carbon atom". For this we can use the Chemical File Database (or of course every other database, even those for proteins.

Expected results:

  • provide GUI for Strigi search results for an element selected in the periodic table
  • provide GUI for Strigi search results for an glossary item

Knowledge Pre-Requisite: Required: C++, DBUS. Could be useful: Qt.

Mentor: Undecided.

Project: Kalzium beautification

Project Information: Many parts of Kalzium could need a fresh up of the interface. For example, the main table should be written using Qt Model/View technique and for example use SVGs as a background. A first (uncomplete but working) code is already existing.

At the same time, many dialogs are not as beautiful as they could be. This project could also include the creation of a "simplified Kalzium" mode in which some parts of the feature set are hidden; this would be good for schools.

A third idea is to make more use of Plasma, for example improve the already written Plasmoids and/or extent Kalzium so that a Plasmoid could open a information dialog using Kalzium.

Expected results: Depending on the chosen project for example a cleaned up codebase with an improved interface.

Knowledge Pre-Requisite: Required: C++, Qt, possible Plasma, Debug.

Mentor: Carsten Niehaus

Project: Molecular calculator

Project Information: Kalzium already has a basic mass calculator for molecules (in the sidebar). The goal of this project would be to add full-blown widget that allows users to calculate masses of molecules, do calculations with them, calculate concentrations (mol/l, g/l..) of solutions... ChemicalDataObject already has the needed data to achieve this, there's a parser for molecule formulas, so the project's goal is to make a nice GUI and of course write code that uses that data in the good way.

Expected results: An easy-to-use (multi-tabbed?) window, where users can enter what they know (molecule name and number of grams...), pick what they want to know (number of mols).

Knowledge Pre-Requisite: Required: C++, Qt, basic knowledge of chemistry.

Mentor: Undecided.


Rocs is a Graph Algorithm Testbed for universities. It aims to give the students a place to visualize the results of the algorithms, so it doesn`t provide any, instead there`s a place for the studant to write them down and see what happened.

Project: Kross support

Rocs only supports QtScript at the moment, and in a really not-smart way, with kross it could use more languages, and have more usecases.

Project: Automate support

Since in a ultimate look, automates are graph, it would be nice to have an automate support for it.


KDE-based Integrated Development Environment, specializing in c++ support, but including a powerful generic framework (definition use chain) which makes it possible to relatively easily support multiple different languages.

Website - Mailing list - IRC channel: #kdevelop on Freenode.

Project: C++ Refactoring Support

Brief explanation: C++ support in KDevelop is already highly advanced, often equalling or surpassing what the user and compiler understand about the code. A few refactoring tools have been developed already, but they have been constructed in a crude fashion, generating code via string concatenation.

This project would aim to create a new system to implement refactoring tools, and to create, test and deploy several advanced refactoring tools for c++.

Expected results: A library would be created to enable refactoring based on the c++ AST (abstract syntax tree). A reverse parser (AST to code) already exists, but classes would be created to allow programatic manipulation of an AST. Optionally this library would also cover a generic framework based on the duchain which would be re-usable by other languages and make refactoring plugins easier to develop and partially shareable between languages.

See the Code Generation Design documents for the initial plan for this project.

Knowledge Prerequisite: C++ and Qt. Experience with parsers would be a bonus.

Mentor: Hamish Rodda (Definition-Use chain code creator) rodda at kde/dot/org, possibly also David Nolden (DUChain guru)(to be confirmed)


Project: support for versioned OpenDocument files.

Explanation: The OpenDocument specification doesn't include support for multiple versions of the same document in a single file. But that feature is supported by OpenOffice.org. The objective for this Summer of Code is to add support for that versioning system in KOffice. Since KOffice shares the OpenDocument loading/saving code, it should be possible to add this support in every KOffice application in one Summer of Code.

Expected results: Being able to load a specific version of a file, and create/manage versions

Knowledge Pre-Requisite: C++, excellent english reading skills.

Project: Add support for e-book formats to KOffice.

Brief explanation: Add a new export for one or more formats that are specifically tuned for e-book devices.

With the increased popularity of ebook readers there is going to be a need for tools to create ebook content. While most e-book devices can display PDF there are in fact a lot more formats in use. One such format is .epub, which allows reflowable content (unlike PDF). The format itself is based on XML and uses style sheets (CSS) to format content. There are few free software tools that can generate and manipulate this format and those that exist are restricted to command line.

Since most people creating content will most likely want to use an office suite or word processor to make documents it makes sense to add an export option for this format to KOffice.

Knowledge requisites:

  • C++
  • XML
  • CSS


Project: support missing ODF drawing shape feature

Explanation: KOffice can already load and save most of the shapes that ODF defines. Still a few features are missing especially text on shapes, but also caption, title, description and the measure shape.

Expected results: The project should implement the mentioned features and it should be possible to load, save and easily edit them

Knowledge Pre-Requisite: C++



Project: Powerpoint import.

Explanation: From some years ago another gSoc project implemented the basis for powerpoint import, but it was never finished. So there is a good basis to start from. From a quick look it seems like styles support is the thing missing most to complete the work, however a thorough analysis of what is there and what is not needs to be done. And then the actual work needs to be done too, obviously


Project: New tile engine for Krita

Project information: Krita's current tile engine suffers from some limitations, like extensive locking. A new tile engine should offer some compelling features, like mipmapping, tile aging, in-memory compression, lock-free access of tiles, as efficient as possible undo information, pluggable backends (like png or tiff). See for a short summary http://wiki.koffice.org/index.php?title=Krita/Akademy_2007_Meeting#tile_backend. Expected Results: an production-ready implementation having these features.

Knowledge Prerequisite: This is a difficult, ambitious project. Applicants should have a good knowledge of C++, data structures and be aware of existing literature on this subject and have a knowledge of graphics applications.

Project: Sketch-pad interface for Krita

Project Information: Krita is a large and complex application built around a sophisticated painting engine. The goal of this project is to create a new interface around the Krita engine, specialized for quick sketching.

Expected results: This project should implement a new interface around Krita, presenting the user a single-layer plus tracing paper interface with a single freehand sketching tool. Easy to use and graphic color and paint operation (brush, pencil, eraser etc.) interface elements must be designed and implemented.

Knowledge Pre-Requisite: C++

Project: Shader filters and generators for Krita

Project Information: Some initial work has already been done to make it possible to write filters in the OpenGL shading language. This project should take that initial code as a basis and implement a fully functioning plugin for Krita that allows filters and shaders to be executed on images in any colorspace.

Expected results: The plugin should have a finished user interface and make it possible to experiment with shader filters in an interactive way. Example filters must be implemented.

Knowledge Pre-Requisite: C++, OpenGL.

Project: Animation support

Project Information: There is no support at all in Krita for animated images such as GIF or MNG or for working with images in an animation context, such as textures or backgrounds in applications like Blender. The applicant should first investigate user needs and use cases and then implement support in the user interface and in the import/export filters.

Expected results: A user-friendly way of working with animated images (i.e., not by making each frame a layer), but e.g. a docker that shows the the animation running in thumbnail format. Import/export filters for relevant file formats.

Knowledge Pre-Requisite: C++

Project: PSD and Gimp plugins

Project Information: Krita is powerful enough to handle nearly all that the Gimp and Photoshop are capable of saving. This project is about creating dedicated file import/export filters that can handle as much of these file formats as possible, possibly through the use of existing libraries.

Expected results: 4 plugins: psd import/export and xcf import/export. These plugins should be able to handle complex files in all supported colorspaces. Ideally the project would also deliver a library to convert PSD/XF to/from Open Raster files.

Knowledge Pre-Requisite: C++

Project: Workspaces

Project Information: A workspace is a loadable package of settings that finetune Krita for a particular purpose. A workspace could contain additional plugins (like an image browser plugin for batch operations) and a subset of resources. Example workspaces could be batch-editing of images, editing of animation sequences or painting or sketching.

Expected results: the user interface and framework to make packages of plugins and resources that users can switch between. Also extra plugins to extend krita in areas like batch processing that do not exist yet.

Knowledge Pre-Requisite: C++, artistic workflow

Project: Kipi and digikam plugins compatibility

Project Information: Kipi and digikam provide lots of interesting plugins for working with 8 and 16 bit RGBA images. It would be great to be able to re-use those plugins from within Krita.

Expected results: Two plugins that load kipi and digikam filters into two new menus in the filter menu. Code to convert Krita layers to the digikam image representation and back, taking care of icc profiles and other niceties.

Knowledge Pre-Requisite: C++, artistic workflow


Project: support for basic flowchart editing

Project Information: In KOffice 1.6 Kivio provided tools and stencils for editing flowcharts. Flake already provides the the building blocks: shapes, glue points and a connector shape. Goal of the project is to recreate old functionality based on flake.

Expected results: Import of the Kivio stencil format. A docker that allows to handle collections of stencils. Implementation of a connector tool, that can easily connect different shapes.

Knowledge Pre-Requisite: C++


KDE PIM is the interest group working on applications related to personal information management, e.g. contacts, calendar, mails, etc.

One of the current challenges is utilizing the new cross-desktop PIM infrastructure called Akonadi.

There are interesting projects on all levels of the software stack: libraries, application porting, new applications, access to online resources, etc.

Website - Project Wiki - Mailing list - IRC channel: #kontact and #akonadi on Freenode.

Project: Akonadi Janitor Agent

Brief explanation: An Akonadi Agent is a service process for performing tasks on data provided through the Akonadi server.

The task of a Janitor agent would be to keep the user's PIM data neatly organized, for example deleting news feed items which are above a certain age and not flagged, moving last week's mail to an archive, etc.

Expected results:

  • An Akonadi Agent capable of managing actions on Akonadi collections triggered by various criteria
  • At least fully working implementation of actions based on "Expire" criterias for mail, e.g. delete mail above certain age, move/copy to different collection, etc
  • GUI for configuring actions and their trigger criteria.

Knowledge Prerequisite: C++ and Qt. Ideally would already have gone through the Akonadi Resource Tutorial since Resources are a specialized form of agents and thus share some of the API and characteristics.

Mentor: Kevin Krammer (kevin dot krammer at gmx dot at)

Project: Alternative Akonadi Client Library

Brief explanation: Akonadi has a server/client like architecture where clients such as applications (but also resource) connect to a service and communicate with it through a suitable protocol.

Currently this is implemented for KDE in library called libakonadi-kde, however it is desirable to have additional implementations to be suitable for other library stacks, e.g. GLib/GObject based ones.

Expected results:

  • A non-KDE based, preferably GLib/GObject based, Akonadi client library which
    • can connect to a running Akonadi server
    • fetch Akonadi collections
    • fetch Akonadi items
    • receive Akonadi change notifications (D-Bus based)
  • A set of demo programs using the library which can
    • recursively list (id and content MIME types) collections
    • list (id and MIME type)oif items in a collection
    • get the raw payload of an item

Knowledge Prerequisite: Depends on the chosen language and toolstack, e.g. C/Vala and GLib/GObject knowledge for a GLib/GObject based implementation.


Project: Akonadi Consistency Checker

Brief explanation: Akonadi provides a structure of collections and items, similar to folders and files of a filesystem. Similarly the internal structures have to follow certain constraints which must not be violated. Nevertheless, this can happen as result of bugs, hardware failures, power loss and a million other reasons.

Filesystem checks exist to detect and possibly fix such situations. Such functionality would also be desirable for Akonadi.

Expected results:

  • A consistency checker (built into the Akonadi server or stand-alone) that performs an extensible set of checks on the internal data structures of the Akonadi server, such as:
    • items belong to existing collections
    • collections are child collections of existing collections
    • the collection tree is non-cyclic
    • every collections is owned by an existing resource
    • collection sub-trees are owned by the same resource
    • every item payload part belongs to an existing item
    • content type constraints of collections are not violated
    • ...
  • each check should be accompanied with recovery code, such as moving orphaned items into a lost+found folder
  • integration into Akonadiconsole
  • integration into unit-tests

Knowledge Prerequisite: C++ and Qt mandatory, SQL/database knowledge would be useful.

Mentor: Volker Krause <[email protected]>

Project: Akonadi Resource for KMail local folders

Brief explanation: KMail stores its mail in a folder hierachy where each folder can contain mails and further sub folders.

While mails are stored either as mbox or maildir, additional index files are used to speed up message listing and to store message status and flags.

The already existing Akonadi MailDir resource can handle the maildir aspects but cannot handle either mbox based folders nor the additional information stored in the index files.

Expected results:

  • a set of classes, probably as a library, capable of
    • recursively listing the KMail folder tree given a base directory
    • reading mails from the mbox and maildir folders in the KMail folder tree
    • reading KMail index files
  • an Akonadi resource using these classes to provide read-only access to all mails currently handled by KMail. The resource should also be able to transfer the flags stored in KMail's index file to Akonadi.
  • Writing a migrator, similar to the current KResource->Akonadi migrator, that automatically reads the KMail config file and creates a Akonadi resource out of it. Optionally, depending on the overall progress, the migrator would also convert some of KMail's folder settings, like the folder icon or the expiry settings, to Akonadi collection attributes.

Knowledge Prerequisite: C++ and Qt mandatory, code analysis skills would be helpful regarding the handling of index files, refactoring skills if KMail's classes are to be extracted from KMail's code base (not required).

Mentor: Thomas McGuire <mcguire at kde dot org>

Project: Improvments in KMail's HTML support

Brief explanation: Improve the HTML support in KMail, especially making it possible to preserve the HTML format when replying or inline forwarding.

While KMail's HTML support has been constantly improving, it still has some important bits missing and some minor bugs. The goal of this project would be to implement the missing features and do general bugfixing in the HTML support.

One of the biggest missing features, with over 1500 votes on bugzilla, is the ability to preserve the HTML format when replying or forwarding, which is often an essential requirement in some enterprises.

Recently, support for inline HTML images was added to KMail. This support needs a few improvements, like being able to put images in the signature or resizing the images.

Currently, KMail relies on QTextEdit::toHtml() to generate the HTML source. This however is very weak, as QTextEdit has some bugs and generally produces HTML that is only equaled by MS Word in its ugliness. Stephen Kelly has started some work to make this output nicer, and to produce other forms of markup, like text/enriched. This is achived by creating so-called rich-text builders. One goal would be to finish this work and integrate it into KMail.

Comment by Thomas; QTextEdit html generation is not optimal due to html simply not supporting all QTextEdit features. Qt45 choose to export to ODF instead. Maybe KMail should try to leverage this instead?

Other nice points would be to support the text/enriched format for reading or composing mails, and to support the text/flowed format when composing. Although this is not strictly HTML related, it would improve the experience for many people.

Of course, your own ideas are very welcome as well

Expected results:

  • Option to preserve the HTML format when replying or forwarding
  • Support inline images also in signatures
  • Improve inline image support by allowing to scale the images
  • Nicer HTML generation by completing and integrating the HTML builder from Stephen Kelly
  • Various bugfixes in the HTML support
  • Optionally, also support text/enriched as alternative to HTML (both reading and composing). See RFC 1896. Composing support can also be based on Stephen's builders.
  • Optionally, support text/flowed format for non-HTML mail (RFC 3676)

Knowledge Prerequisite: Moderate C++ and basic Qt knowledge mandatory

Mentor: Thomas McGuire <mcguire at kde dot org>

Project: import/export for filtering rules in Sieve format in KMail

Brief explanation Add functionality to import/export of mail filtering rules in Sieve format in KMail.

Sieve is a language for declaring mail filter rules on a mail server. It was developed as part of the Cyrus IMAP server, but was quickly spin off and turned into a standard (http://tools.ietf.org/html/rfc5228). There are quite a few servers that have support for Sieve, in various degrees of completeness. It is quickly gaining support. Clients that support it are KMail and Thunderbird.

KMail already has support for talking to Sieve enabled servers and also has support for client side filters. These two rule sets seem to be separate. It would be nice if you could dump the rules you have in one client and able to either install them on a server, or load them into another client, if you want to access your mail from different machines, but don't want to reconfigure your mail clients over and over again, or to quickly reconfigure clients if you don't have a Sieve enabled server.

Expected results: Successful import and export of a (subset) of mail filtering rules between various KMail instances.

Knowledge requisites

  • C++
  • knowledge of how mail works

KDE on Windows

Solid API backend

Brief explanation: The porting efforts to make KDE available across platforms do need some backends for system dependent tasks. One of the KDE libraries that bundles this is Solid.

Expected results: You implement a backend for the Solid API using WINAPI. It has to work with both MinGW and MSVC compilers. Not every function is required, but the basic functionality (network access, removable drives/harddisks and power) should be implemented.

Knowledge Prerequisite: Windows API and C++/Qt. You should be able to set up the development environment yourself and be familiar with it.

Mentor: Carlo Segato (brandon dot ml at gmail dot com) or Patrick Spendrin (ps_ml at gmx dot de)

KDE Games

Project: Mancala game

Brief explanation: Mancala is a family of board games played around the world, sometimes called "sowing" games, or "count-and-capture" games, which describes the game-play. Mancala games play a role in many African and some Asian societies comparable to that of chess in the West. The list of mancala games best known in the Western world includes Kalah and Oware. Other games are Congkak, Omweso, Ünee tugaluulakh, Bao, Sungka and Igisoro.

The word mancala comes from the Arabic word naqala meaning literally "to move." There is no one game with the name mancala; instead mancala is a type, or designation, of game. This word is used in Syria, Lebanon, and Egypt, but is not consistently applied to any one game.

In the USA, however, "mancala" is often used as a synonym for the game Kalah.

Expected results: The aim of this project is developing Mancala game with lively interface that is changeable depend on the culture user chose to play. For example, if user choose Africa Culture, the interface will be a board drew on sand with several stones plus sounds of jungle, wild-animals...

Contact me to get more details Name: Mr. Phan Quoc Huy

Student in University Of Science, Ho Chi Minh city, Viet Nam

email: [email protected]

Mentor: Anyone find this is an interesting project please feel free to contact me, I'm very willing to implement it for KDE4.

Project: Kolf 2 landscape object

Brief explanation: Kolf 2 is the second incarnation of KDE's minigolf game. We are currently rewriting it from scratch to take advantage of the powerful technologies provided by Qt 4 and KDE 4.

Expected results: The task in this project is to create an object (or multiple objects) that provide(s) landscape textures, slopes, puddles and sand bunkers.

If you finish this task before the end of the summer, you can fill the remaining time by porting as much game objects from Kolf 1 to Kolf 2 as possible (e.g. windmills, floating blocks, signs or bumpers).

Knowledge Prerequisite: C++/Qt. Experiences in graphics programming with Qt will definitely help, as you are expected to implement 2D rendering for the landscape object.

Mentor: Stefan Majewsky (majewsky at gmx dot net) – Please contact me to let me help you to improve your proposal.

Project: Kolf 2 editor interface

Brief explanation: The minigolf game Kolf provided an editor interface from the beginning, to allow the users to create custom courses. For Kolf 2, we are rewriting the game engine and can therefore not use the old editor code.

Expected results: Your task would be to create an editor interface (may be embedded in the game, or a standalone application). A few basic parts are available, and the Kolf 2 engine supports generic methods to provide data to editor interfaces, and display editor overlays on the game view.

If you finish the editor interface before the end of the summer, you can fill the remaining time by porting as much game objects from Kolf 1 to Kolf 2 as possible (e.g. windmills, floating blocks, signs or bumpers), or using your editor to put together some cool courses.

Knowledge Prerequisite: C++/Qt. Experiences in model/view programming with Qt will be of good use.

Mentor: Stefan Majewsky (majewsky at gmx dot net) – Please contact me to let me help you to improve your proposal.

Project: Parsek – advanced galaxy conquest client

Parsek is a client for playing 4X (explore, expand, exploit and exterminate) galaxy conquest strategy games, which are created using Thousand Parsec framework. You can think of it as an advanced version of Konquest.

Brief explanation: Parsek uses the existing C++ Thousand Parsec protocol library to create a KDE 4 graphical game client. The client is then used to connect to any game server running any game created using Thousand Parsec framework. Some code (you can find it in playground/games/parsek) is already written (to get object of the universe and messages) but you can't play the games yet. The student's task will be to bring Parsek at least to a state so that people would be able to play games with it.

Expected results: To be able to play games some features must be added: displaying a star-map, displaying object info in a nice way, displaying messages in a nice way, getting and displaying object orders, creating new orders. If there is some time left after before mentioned required features are implemented the student will work on additional optional features, for example: automatic discovery and display of game servers (on local network and/or from meta-server), game servers accounts manager, plug-in for game server administration, Plasma widget with overview and quick access to the games someone is playing, single-player wizard (to easily setup local server and AI clients)...

Prerequisites: C++/Qt (experience with model/view and graphics view programming is a plus), experience with similar 4X games (Stars!, Galactic Civilizations, Master of Orion, Space Empires, Spore, ...)

Mentor: Jure Repinc (jlp at holodeck1 dot com). Contact also on #kdegames/#tp channels on freenode.net (nickname JLP) and kde-games-devel/tp-devel mailing lists.


Project: DOM3 XPath Level 1 and/or DOM selectors API support in KHTML

Brief explanation: Because JavaScript frameworks have popularized access to parts of documents using various query languages, direct browser support for such queries has become fairly common. This project is about adding support for one (or two) of such languages to KHTML. Basic implementation of each is expected to be simple, but there may be some interesting optimization opportunities to explore.

Expected results: Implementations of XPath 1 or DOM selectors API at DOM level with appropriate JavaScript bindings that are standard-compliant, written in simple & maintainable fashion, and perform reasonably well.

Knowledge Prerequisite: C++, and some comfort with working with large codebases.

Mentor: Maks Orlovich (maksim at kde dot org)


Project: UPnP support through Jolie

Brief explanation: Adding UPnP support to Solid would mean offering transparent UPnP support to every KDE application using the Solid API, keeping them clean from every UPnP implementation aspect. At the present, the Jolie language is being integrated with Plasma by means of the QtSodep library, soon to offer higher levels of abstraction.

The aim of this project would be to implement a UPnP protocol for Jolie, so that Solid could re-use the integration being made with QtSodep and gain UPnP support without having to worry about implementation details. Having a UPnP protocol implementation in Jolie would have other considerable consequences, like the possibility to act easily as a UPnP server or to compose and export existing UPnP services.

Expected results:

  • The creation of a "upnp" protocol in Jolie, supporting at least the Internet Gateway Device (IGD) and MediaServer profiles.
  • The creation of a UPnP Jolie service for UPnP service discovery and monitoring.
  • Extending libsolid to expose UPnP devices found on the network.

Material Prerequisite: Having UPnP devices or software applications to test with. Most home routers support IGD, and there exists free software supporting the MediaServer profile (mediatomb).

Knowledge Prerequisite: Understanding of the UPnP specifications, Java (for the development of the Jolie UPnP protocol) and basic knowledge of the Jolie language.

Mentors: ervin (ervin at kde dot org) fmontesi (famontesi at gmail dot com)


KDE's window manager

Techbase page - Mailinglist - IRC channel: #kwin on Freenode.

Project: Window tabbing

Brief explanation: Window tabbing is a feature that allows you to group multiple application windows together to cover the same space. It is identical to what is already available in any modern web browser except it applies the the window as a whole. Window managers that have this feature available include Fluxbox and Ion. This feature was originally requested in 2002.

Knowledge Prerequisite: C++ and Qt. Understanding of the X window system and Xlib is a benefit but not required.

Mentors: Lucas Murray (lmurray undefinedfire com)

Project: Window tiling

Brief explanation: Window tiling is a technique of displaying application windows side-by-side without overlap. The position, size and layout of the windows can either be specified by the user or determined automatically to best fit the screen. Examples of existing tiling window managers include Awesome, XMonad, Ion and Ratpoison. One of the main advantages of tiling is that is makes application windows easy to navigate solely by the keyboard. This feature was originally requested in 2003.

Expected results:

  • Users should be able tile existing floating windows on-the-fly with simple keyboard shortcuts or mouse gestures.
  • It should also be possible to run the entire desktop environment entirely in tiled mode (Enabled by configuration settings). In this mode new window would be added to the tiling grid by default yet can be removed by the user if required.
  • The final tiling system should not interfere in any way with the existing floating window management.

Knowledge Prerequisite: C++ and Qt. Understanding of the X window system and Xlib is a benefit but not required.

Mentors: Lucas Murray (lmurray undefinedfire com)


Photo Management program

digiKam project web site - Mailinglist - IRC channel: #digikam on Freenode.

Project: High Dynamic Range (HDR) plugin

Project Information: digiKam is an advanced digital photo management application for KDE, which makes importing and organizing digital photos a "snap". The photos are organized in albums which can be sorted chronologically, by folder layout or by custom collections. digiKam has an Image Editor which has its own plugin subsystem with some common tools e.g. red eye correction or Gamma correction. Additional plugins are provided with the main application to process advanced corrections on image like color management, noise reduction, or special effects. digiKam image editor support 16 bits color depth image internally. The goal of this project is to create a new plugin dedicated to create HDR image.

Expected results: This project should implement an HDR tool will mix two or more (nearly) identical images having different exposure into a new image representing a wider dynamic range, which is closer to human perception of a photographic scene. Tone-mapping method must be used to create HDR images. An open-source implementation is already available at this url and can be re-used as well. There is an old feature request.

Knowledge Pre-Requisite: C++/Qt.

Mentors: Gilles Caulier (caulier dot gilles at gmail dot com)

KDE Telepathy Integration

The Telepathy Framework is a desktop independent framework for real-time communication, such as VoIP and Instant Messaging. The projects below are some ideas for integrating telepathy into KDE.

If you want to know any more about Telepathy and KDE, drop by the irc channel #decibel and talk to grundleborg, or use the mailing list decibel AT kde DOT org.

Project: Message Logging

Project Information: The Telepathy Framework allows for components which can watch channels whilst a user is interacting with them through another application. A program could be created to log the content of text instant messages into an Akonadi collection.

Expected results: This project should result in a telepathy watcher which is capable of logging the contents of text chats into an Akonadi collection. It should be possible to go off-the-record in a particular conversation from telepathy user interfaces and the logger should not save any messages in this situation. This project might also include modifying the Kopete logging plugin to use the same akonadi collection for logs, and making a migration tool from Kopete's old logging format to the new Akonadi collection.

Knowledge Pre-Requisite: C++/Qt, some basic knowledge of the Telepathy Framework is an advantage, but not necessary if you have an interest in real-time communcation and are prepared to learn fast.

Mentors: George Goldberg (grundleborg at gmail dot com) IRC: grundleborg

Project: Telepathy Integration to any KDE application

Project Information: Provide some collaborative feature or instant messaging integration for your favourite KDE application.

Expected results: This project should result in a collaborative feature or instant messaging integration being added to the chosen KDE application. It should be complete enough to provide at least basic functionality to end users, with the possibility of further improvement after the summer of code period ends.

Knowledge Pre-Requisite: C++/Qt, some basic knowledge of the Telepathy Framework is an advantage, but not necessary if you have an interest in real-time communcation and are prepared to learn fast.

Mentors: George Goldberg (grundleborg at gmail dot com) IRC: grundleborg. You should also discuss your idea with the development team of the application in which you would like to provide a Telepathy feature.

Project: Telepathy Plasma Integration

Project Information: Provide integration of presence and buddy information into plasma.

Expected results: You should provide multiple points of integration between presence and contact information and plasma. Plasmoids allowing the display and manipulation of your own presence information should be made available, building on the plasma applets and datengines already in existance for presence information. Plasma activities could also be made aware of presence, and the contacts plasmoid could be made aware of your buddies from Telepathy instant messaging accounts.

Knowledge Pre-Requisite: C++/Qt

Mentors: George Goldberg (grundleborg at gmail dot com) IRC: grundleborg. You should also discuss your ideas with the plasma development team before making a proposal.


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

Project: A Context Sidebar

Brief Explanation: The ideas is to have a sidebar on the desktop (see Plasma project above for example) which shows information about the resource in the current context. Examples include files or important emails from a specific person that sent the email I am currently reading. Or related information on a webpage I am currently browsing. Or the author information on a pdf I am reading. And so on. The sidebar should pick up DBus signals that can be sent out by any application to change the current resource (this is just an idea).

Expected Results: Creation of the sidebar and integration into at least two applications (like KMail or Okular) which will then update the resource in focus. It might also be good if the sidebar could monitor if the application that set the resource looses focus or is closed.

Knowledge Pre-Requisite: C++/Qt/KDE/Plasma

Mentor: Sebastian Trueg (trueg at kde dot org)

Project: Saving and Loading of Documents via Meta-data

Brief Explanation: Today we still save and load our documents using a file browser. We navigate through folder structures that we created and try to find the best spot for the document. Another way would be to store a document by specifying meta-data about it. We could for example set the type (not the mimetype but the actual type like it is a letter or an invoice or a holiday picture and so on) or set properties on the document like related projects, related persons, tags, and so on. The system would then store the document someplace (we don't care about that). Loading the document would work the same way: filter documents according to type, date, persons or any other property we might have chosen to describe it. In KDE applications today can predefine the file extension. How about letting the application predefine a set of meta-data properties.

Expected Results: A prototype for saving and loading documents via meta-data and at least one use case which is demoable.

Knowledge Pre-Requisite: C++/Qt/KDE, knowledge on ontologies and RDF are very helpful

Hints: One might think of a plugin system here that allows to suggest annotations to the user. Compare the annotation system already in playground based on Nepomuk::Annotation.

Mentor: Sebastian Trueg (trueg at kde dot org)

Project: Improved Virtual Folders

Brief Explanation: KDE 4.2 contains a KIO slave which uses Nepomuk to provide virtual folders (nepomuksearch:/). It has not been deeply integrated into KDE yet (such as the file dialog or Dolphin). The project would change this situation and allow to browse virtual folders in addition to simply use it as a search client. Ideas include subfolders which sort by result type or allow to refine the search. Also interesting is the saving of virtual folders and a graphical interface to define searches (folders).

Expected Results: An improved version of the virtual folders which is highly usable without prior knowledge (such as the nepomuksearch:/ scheme). The possibilities are vast.

Knowledge Pre-Requisite: C++/Qt/KDE

Mentor: Sebastian Trueg (trueg at kde dot org)

Further information:

Project: Konqueror Bookmarks using Virtual Folders

Brief Explanation: A bookmark plugin for konqueror, that creates a bookmark folder structure on the fly, out of the tags that are assigned to each bookmark-item. A bookmark could be a local or remote file, of any kind: html/pdf/video/… The tags could either be assigned by the user(with a very simple/quick interface), or just indexed automatically.

Expected Results: A virtual folder structure that would replace or supplement the current bookmarks toolbar. E.g. one could find the digikam web page either like: Linux->KDE->multimedia->[digikam], or Photography->Programs->[digikam]. Because the bookmark has all these tags: Linux,KDE,multimedia,Photography,Programs. An initial database could be created by importing the current bookmarks.xml file, using the directories as tags.

Knowledge Pre-Requisite: C++/Qt/KDE

Mentor: Sebastian Trueg (trueg at kde dot org)

Further Information:

This page was last edited on 7 March 2009, at 00:26. Content is available under Creative Commons License SA 4.0 unless otherwise noted.