Projects/Summer of Code/2008/Ideas

From KDE TechBase

This page is an open list for ideas for the 2008 edition of Google Summer of Code. This page is open for new ideas from anyone.

This list is not exhaustive. It is just a collection of some ideas. To get further ideas, please feel free to use any resources and past ideas.

Before proceeding, please read the participation instructions and the notes on editing this page. They are useful for students and developers alike.

Past ideas

You may want to take a look at the ideas page for 2006 and 2007. Many of the ideas there are still valid today.

Project ideas

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.

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.

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)

KDE Libs

KDE Core libraries

The KDE core libraries (kdecore, kdeui, kio, kparts) are the most basic libraries that all KDE applications depend upon.

Solid

Solid is the KDE hardware abstraction layer, that enables KDE programs to get consistent results when running on different platforms.

Phonon

Phonon is the KDE audio abstraction layer, that enables KDE programs to produce basic and medium-level multimedia functionality in any platform without platform-specific code.

KHTML

KHTML is the current KDE HTML engine, used by the Konqueror web-browser and other applications to display HTML in their interfaces.

KJS

KJS is the JavaScript engine used by KHTML and Kross to run JavaScript programs.

Sonnet

Sonnet is the KDE grammar, spell-checker and language-detection engine.

Kross

Kross is a modular scripting framework that provides a complete framework to embed scripting interpreters like Python, Ruby and KDE JavaScript transparently into native applications to bridge the static and dynamic worlds together.

Oxygen

Oxygen is the KDE 4's default look-and-feel. It comprises of the Oxygen icon set (including the palette and guidelines for icons), the Oxygen sound theme, the Oxygen wallpaper collection, the Oxygen window decoration and the Oxygen widget style. Note that for Summer of Code, you must produce code, so the window decoration and widget styles are your more likely candidates.

KDE-Print

  • Implement an easy usable fineprint-like solution for collecting pages from different printing sources (browser, kword, krita...) and allow it to rearrange single pages (not printing jobs), delete pages, add blank pages. Information also in wish-list-item: 90989. I am the reporter of this wish, you can contact me there. I do not have the abilities to program, but I am willing to help testing an implementation and discuss how it should look like.
  • WARNING! i'm doing exactly thos for my semester project at school (we are two students, so we can't apply for SoC with this).We are probably developing it in pure QT (the other student is a gnome user).You can get in contact with me: [email protected]

KDE Base applications

Konqueror

Konqueror is KDE's powerful web browser and file manager.

Project: Bookmark Wallet

Description: This isn't actually a project to be a part of Konqueror itself, but rather a separate application similar to KWallet. The application should provide a database for the storage of URL bookmarks. The database should be able to connect to remote storage, such as the google bookmarks service, for synchronization and backup. The URLs should be easily manageable, and include a concept of ratings for the URLs. A plugin should be written to allow Konqueror to easily interface into the system, or preferably Konqueror itself should be modified to use the storage system when it is available. The application should provide an interface which is easy to connect to from a browser plugin, so that plugins could be written for other browsers, such as Firefox, as well. There should also be a plugin interface into the database, to allow support for other remote storage backends, such as foxmarks, to be created. The application should handle multiple concurrent connections to the database without issues. Additionally, the application should provide an event interface to notify all connected browsers whenever a bookmark is added, changed or removed.

Comment: Rather than developing a separate application, interested students should have a look at the Akonadi resource localbookmarks

Dolphin

Dolphin is KDE 4's default file manager application.

Konsole

Konsole is KDE's terminal application.

Kate and KWrite

Kate is KDE's Advanced Text Editor, both a full-featured text editor application and a KPart engine ready for embedding into other applications (like KDevelop, Quanta and Kile). KWrite is a simple text editor based on the KatePart engine and is KDE's default text editor.

KDE Workspace

Plasma

Plasma is KDE 4's desktop and panel tool, replacing KDE 3's kicker and kdesktop. It's an advanced and powerful application with revolutionary ideas.

  • Setting a video as desktop background.
  • Datasource + applet for zeroconf services

KRunner

KRunner manages the screen locking, run command dialog and provides a general natural language interface to applications, desktop services, network locations, files and data (e.g. math calculations, spell checking, word definitions, etc). It replaced the Run Command dialog in kdesktop from KDE3, is multithreaded and shares code with Plasma.

KWin

KWin is KDE's X11 Window Manager program, greatly improved when compared to its older brother in KDE 3.

KDM

KDM is KDE's Display Manager and login application.

KDE Runtime

KOffice

KWord

Project: Improve ISO OpenDocument support

Explanation: Improve loading and saving of the ISO OpenDocument format what includes 1) extend the current saving code, 2) extend the current loading code and 3) probably also extend the rendering engine aka the text flake-shape.

Expected results: be sure everything we are able to load, display and edit is also saved back correct using the default file format.

Mentor: Sebastian Sauer <[email protected]>

Project: Collaborative editing of documents over a network.

Explanation: Make it possible for two or more users to work at the same document in KWord at the same time over a network. Both users would open the same document, and changes made by each user are synchronized to the other user's editing session.

Project: Version control integration.

Explanation: Integrate version control system support with KWord to allow easy control over revisions of documents. It should be possible to connect with remote revision control systems, to allow collaborative work on projects, similarly to how software is developed. It should be easy for the user to browse through the history of document versions in the version control system, to see what has changed. CVS, Subversion and git should be supported.

Project: Improve legacy MS Office (2003) documents support

Explanation: Current MS Office formats support is kinda limited (especially write support). To decrease the barrier for adoption, better MS Office support is a way to do that.

KSpread

Kexi

Krita

Project: Sumi-e brush engine

Project Information: While there is already an attempt at a sumi-e brush engine in Krita, the current code is limited and uses an old-fashioned way of simulating brushes.

Expected results: This project should implement an anti-aliased, bidirectional ink-transfer simulation of a sumi-e brush, together with a user interface to define brushes. The brushes should react to pressure, tilt and rotation of the a tablet stylus. The results should be realistic. Loan hardware for use during the development phase is available.

Knowledge Pre-Requisite: Basic knowledge of basic 2d graphics principles. A list of relevant papers and books is available.

Mentor: Boudewijn Rempt <[email protected]> The mentor can help preparing the project proposal for submission to Google.

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

Mentor:

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.

Mentor:

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

Mentor:

Project: RAW plugin

Project Information: Krita's current raw plugin is based on a shell exit to dcraw. This is not sufficient and needs to be re-implemented.

Expected results: A next generation plugin should implement loading of raw images either through libopenraw or libkdcraw; preferably designed in such a way that we can switch libraries when opportune. The plugin should allow the user to set conversion parameters in a way that is useful to photographers. An extension to this project could be the implementation of a bayer colorspace model: that is, a colormodel that allows us to load the raw images and edit them in the native raw format, without conversion.

Knowledge Pre-Requisite: C++

Mentor:

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.

Knowledge Pre-Requisite: C++

Mentor:

Project: Photoshop-compatible brush engine

Project Information: A paintop plugin that can load and handle current photoshop brushes. This entails reverse engineering of the Photoshop brush file format and implementing a procedural brush engine that matches the Photoshop brush engine.

Expected results: A procedural brush engine with settings dialog that can load and save current photoshop brush files.

Knowledge Pre-Requisite: C++

Mentor:

KDE SDK

Umbrello

Umbrello is the UML drawing and design tool in KDE.

Project: Add the capability to draw SysML diagrams (http://www.omg.org).

KDE Edu

Marble

Project: Marble - Routing

Project Information: Marble is a generic geographical map widget and framework that is meant to be used by KDE4 applications. It is also distibuted as a standalone application in KDE4.

Brief explanation:

  • Build on the inclusion of OpenStreetMap data in Marble.
  • Implement routing algorithms, ex. A*
  • implement a display of the route on the globe.
  • Optionally, show a list of roads and turns to get to destination.

Expected results: Ability to chose start point, end point and type of transport (car, bike, foot etc.) and get a display of a route on the globe.

Knowledge Pre-Requisite: Required: C++. Could be useful: Qt, knowledge of OpenStreetMap.

Mentor:

Step

Project: Step: 3d mode

Project Information: Step is an interactive physical simulator for KDE. Currently it lives in playground but it will be included in kdeedu package for KDE 4.1.

Brief explanation: Implement physical simulation in 3d. This involves:

  • convert all classes in StepCore to templates with dimension as a template parameter, implement specialized versions where required, modify meta-object system to handle it
  • implement 3d mode in GUI: viewing and editing

Expected results: Ability to create, edit and view 3d simulations in Step with the same set of objects as in 2d.

Knowledge Pre-Requisite: Required: C++, basic OpenGL, basic physics (mechanics). Could be useful: Qt.

Mentor: Vladimir Kuznetsov <ks dot vladimir at gmail dot com>

Project: Step: a game

Project Information: Step is an interactive physical simulator for KDE. Currently it lives in playground but it will be included in kdeedu package for KDE 4.1.

Brief explanation: The idea is to create a game based on physical simulation where the player have a fixed list of equipment (like springs, balls, cat and mice, teapot, etc.) and should use it to build a machine to achieve a given goal (for example put the ball in a basket, capture the mice, prepare a tea, etc.). The user places the equipment, than press Start button which starts physical simulation and if (in certain time limit) the goal is achieved the game is won. In the other case the user could try again. Similar projects: old game named "The Incredible Machine" and newer (but commercial) one named "Crazy Machines".

The game can be implemented as standalone application using StepCore or as special restricted 'game' mode for Step (probably with tweaked graphics).

Expected results: Playable game and several levels to test it.

Knowledge Pre-Requisite: Required: C++. Could be useful: Qt, basic physics (mechanics).

Mentor: Vladimir Kuznetsov <ks dot vladimir at gmail dot com>

Project: Step: simulation of chemical reactions

Project Information: Step is an interactive physical simulator for KDE. Currently it lives in playground but it will be included in kdeedu package for KDE 4.1. This project also relates to Kalzium.

Brief explanation: Simulate some basic chemical reactions using classical molecular dynamics methods with empirical potentials. At first initial settings for simulation should be prepared by hand (as XML file), if there will be enough time an editor could be implemented too. This project involves:

  • convert required classes from StepCore to handle 3d simulations (you will need only several classes which are trivial to convert)
  • implement required objects and potentials in StepCore
  • implement GUI for observing the simulation (investigate the possibility to use avogadro library for visualization), GUI should also allow altering of some properties like masses and charges
  • prepare demonstrations of several common reactions

Expected results: Chemical reaction viewer which could load predefined experiment, modify some basic properties and run the simulation. Prepared simulation for several common reactions.

Knowledge Pre-Requisite: Required: C++, physics, basic chemistry. Could be useful: Qt, basic quantum mechanics, knowledge of common molecular dynamics simulation technics and numerical methods.

Mentor: Vladimir Kuznetsov <ks dot vladimir at gmail dot com>

Project: Step: fast water and gas simulation

Project Information: Step is an interactive physical simulator for KDE. Currently it lives in playground but it will be included in kdeedu package for KDE 4.1.

Brief explanation: Currently Step has molecular dynamics based simulation of gas and water (that is a gas is simulated as a collection of particles). This is very usefull for demonstrating microscopical properties of the gas as well as its connection with macroscopical quantities like temperature. But this is far from optimal to demonstrate things like a boat floating in the water, water flowing from a glass, etc. This project involves:

  • investigate fast methods of simulating water and gas: ranging from molecular dynamics but with simplified potentials, various optimizations, coarse graining methods, to lattice Boltzmann methods; investigate existing libraries for water simulation (for example take a look at elbeem library from Blender)
  • implement selected method of simulation or incorporate selected library in StepCore
  • implement GUI in Step for creating and modifying macroscopical quantities of gas and watter

Expected results: Ability to easily simulate in Step experiments like a boat floating in the water, water flowing from a glass, etc.

Knowledge Pre-Requisite: Required: C++, physics, numerical methods. Could be useful: Qt.

Mentor: Vladimir Kuznetsov <ks dot vladimir at gmail dot com>

Project: Step: other ideas

Project Information: Step is an interactive physical simulator for KDE. Currently it lives in playground but it will be included in kdeedu package for KDE 4.1.

Brief explanation: These are smaller ideas related to Step. You can combine several of them to compose you project.

  • use KAlgebra library for parsing user-supplied expressions in PropertiesBrowser; allow value in Meter, x- and y-values in Graph to be arbitrary expression; implement ParametricForce object that will apply a force given by user-supplied expression; implement a series of ParametricJoint objects that will allow creation of various parametric constraints (like fixed particle trajectory)
  • scripting for Step using either QtScript or Kross
  • multi-threaded calculations in StepCore (knowledge pre-requisite: multi-threaded programming)
  • correctly handle stiff problems in StepCore (knowledge pre-requisite: numerical methods)
  • calculation of gravitational and electromagnetic force between non-point objects by integrating (knowledge pre-requisite: numerical methods)
  • make StepCore compilable without Qt
  • improve soft-body support: implement automatic creation of arbitrary-shaped soft bodies, investigate better (more accurate) methods of modeling soft bodies (knowledge pre-requisite: physics)
  • framework for dynamic object creation/destruction in order to allow implementing particle emitters
  • statistical models (for example prey/predator model)

If you have other ideas please feel free to propose them !

Mentor: Vladimir Kuznetsov <ks dot vladimir at gmail dot com>

KDE PIM (Personal Information Management)

Kontact

KOrganizer

KPilot

KMail

Akonadi

Project: Akonadi backend for Microsoft Exchange Groupware server

Project Information: Akonadi (http://kdepim.kde.org/akonadi/) is the framework for groupware and other PIM applications for KDE4.1 and later. The proposed SoC task will implement an Akonadi backend to allow users to work with Microsoft Exchange servers and applications using compatible protocols (e.g. Outlook).

Brief explanation: The implementation will almost certainly need to use the OpenChange (http://www.openchange.org) libraries. A proof-of-concept implementation has been done (available in KDE's SVN archive), but has bit-rotted as the OpenChange libraries have evolved. It does not currently compile.

Expected results: A completed, and tested, backend that can operate with a current Microsoft Exchange server. Important capabilities include:

  • ability to receive mail,
  • ability to create and receive appointments, and to view the calendar,
  • ability to access the address book, and
  • ability to create and receive tasks.

Sending mail is outside the scope of Akonadi, and is a "growth" potential if the project is proceeding particularly well.

Knowledge Prerequisite: You need to have some familiarity with groupware applications (e.g. knowledge of how appointments and address books are used). C and C++ is pretty much essential, and at least passing knowledge of Qt. It would be useful (but not absolutely essential) if you had access to a Microsoft Exchange server you can use for testing - we may be able to arrange access.

Mentor: Optional, possibly Brad Hards <[email protected]>

KDE Games

KDE Development & Web Development

Kompare

Project Information: Kompare is a graphical difference viewer.

Project: Semantic diff

Brief explanation: Implement a plugin-based approach for different (potentially incomplete) diff-algorithms. Documents are not just lines of text, but have semantics, and these plugins should help to see changes made to the document.

Possible plugins are:

  • File information diff: show date, size, last-modification, ...
  • Programming language diff: detect changes like renamed variables, reindentation, namespace-changes, changes in comments, other refactorings ... (the more the better)
  • XML-diff
  • Latex-diff: whitespace is ignored.
  • config-file diff: in many config-files the order does not matter.
  • Image diff: at least show both images next to each other.
  • Video diff: show both videos next to each other and link their time. Should be interesting for diffs after reencoding.

Expected Result: A native and Kross (for scripting) plugin-support for Kompare. Some of the above mentioned plugins.

Knowledge Pre-Requisite: Some knowledge of the Qt/KDE framework. Knowledge of C++.


KLinkStatus

Project Information: KLinkStatus is a link checker, part of the kdewebdev module.

Project: Aided correction of broken links

Brief explanation: Currently, it is possible to find out broken links but it is not possible to fix them. It would be great if those links could also be corrected within KLinkStatus. The corrector should present the user with sugestions, like a spell checker does (it might be possible to reuse some of the KSpell heuristics). Possible errors are typos in domain and paths, absolute vs relative path, and wrong directories.

Expected results: Ability to fix broken links, being efectivly assisted with suggestions.

Knowledge Pre-Requisite: Some knowledge of the Qt/KDE framework. Language wise, this feature can be implemented using C++ or a script language like Python, Ruby or Javascript.

Mentor: Paulo Moura Guedes <moura at kdewebdev dot org>

Project: Site check automation

Brief explanation: KLinkStatus already provide a D-Bus interface that allows to check sites in the background based on a configuration file and then export the results to HTML. A system administrator can already automate check using cron jobs. However it would be nice to offer a nice frontend inside KLinkStatus (without the need of super user permissions). The results could then be exported into files and/or emailed to the site administrator.

Expected results: Easy site check automation and notification system.

Knowledge Pre-Requisite: Some knowledge of the Qt/KDE framework. Language wise, this feature can be implemented using C++ or a script language like Python, Ruby or Javascript.

Mentor: Paulo Moura Guedes <moura at kdewebdev dot org>

Project: HTML validation

Brief explanation: HTML validation is a very requested feature by users. KLinkStatus already have the infrastructure for this, using libtidy, but some work is still missing in order to actually correct the HTML documents.

Expected results: - Visual indication of which document have HTML validation problems - Ability to fix individual documents or several documents at a time - Ability to efectively preview, compare (perhaps using the Kompare kpart) and edit partial parts of a document - Configurable HTML validation parameters

Knowledge Pre-Requisite: Some knowledge of the Qt/KDE framework. Language wise, this feature can be implemented using C++ and, for some parts of it, a script language like Python, Ruby or Javascript.

Mentor: Paulo Moura Guedes <moura at kdewebdev dot org>

KDevelop

Quanta

KDE Network

KRDC

Add NX support to KRDC.

Project: NX support in KRDC.

Brief explanation: KRDC lacks NX support, which is gaining momentum in the free software world. Build upon the work done by George Wright in the 2006 SoC and the work done by Urs Wolfer in the 2007 SoC to create a top quality NX client for KDE.

Expected results: Fully working NX integration for KRDC, including support for advanced NX features such as sound, VNC/RDP tunnelling etc. Feature parity with the commercial NX client shouldn't be necessary, but aiming for that isn't a bad idea. All NX connection handling code should be in the cross-platform client library nxcl (C++/STL/autotools), and all GUI specific code should be in KRDC.

Knowledge Prerequisites: Knowledge of the NX protocol (see http://www.gwright.org.uk/protocol.pdf for an older version of the protocol), C++/STL/Qt/KDE coding and cross platform coding.

Resources: http://freenx.berlios.de , http://blog.gwright.org.uk/articles/category/nx , http://nomachine.com/ , http://svn.berlios.de/wsvn/freenx

Mentor: George Wright <gwright at kde dot org>

Decibel

Decibel is a realtime communication framework for KDE 4.x.

Project: KDE4 integration

Brief Explanation: Decibel should integrate well with the KDE 4 environment. This includes getting contact data from Akonadi and storing contact state there, storing account data in KWallet as well as integration with Nepomuk to store semantic information on connections made.

Expected Results: A working and tested implementation of integration components.

Knowledge Prerequisites: A good overview of the involved KDE 4 technologies is required.

Resources: http://decibel.kde.org/, Akonadi documentation

Mentor: Tobias Hunger <tobias at aquazul dot com>

Project: Filtering framework for text messageing

Brief Explanation: Text message that are passed to applications using the Decibel framework should get filtered. This includes processing steps (like processing of Off the record messages) as well as logging, etc. This filtering framework needs to be made more flexible as it currently is and some basic filters need to be written.

Expected Results: The filtering API of Decibel is improved and sample filters are developed and tested.

Knowledge Prerequisites: A good understanding of Decibel is required.

Resources: http://decibel.kde.org/

Mentor: Tobias Hunger <tobias at aquazul dot com>

Project: Improve Telephony features

Brief Explanation: Decibel currently has limited support for telephony features required for VoIP integration. This support needs to be improved and missing features (call forwarding, conferencing, etc.) should be implemented.

Expected Results: A VoIP backend based on the existing telepathy backend with the additional telephony features implemented.

Knowledge Prerequisites: A good understanding of Decibel is required. Familiarity with the telepathy spec and VoIP is helpful.

Resources: http://decibel.kde.org/, http://telepathy.freedesktop.org/spec.html

Mentor: Tobias Hunger <tobias at aquazul dot com>

Kopete

Amarok

Project: Nepomuk collection

Brief explanation: Amarok 2 has a plug-in system that allows it to access music metadata from various backends. A plug-in to read and write data to and from Nepomuk should be written in this project. Additionally, Amarok should be extended to make real use of Nepomuk's capabilities by re-adding labels support.

Expected results: A plugin to use Nepomuk as a metadata store from Amarok. Additionally, support for labels should be added to Amarok 2.

Knowledge Prerequisite: C++ is essential, knowledge of Qt and KDE would be helpful

Mentor: Potentially one of several. Contact the amarok mailing list or ask in our IRC channel #amarok

Project: Script manager in 2.0

Expected results: A working script manager as in 1.4 with the additional abilities to

  • disable scripts based on a blacklist (which is maintained on amarok.kde.org, known insecure scripts get blacklisted using cryptographic signatures), but still let the user be able to run them anyway after confirmation
  • recognize which version of Amarok a script is compatible with
  • easily update scripts (maybe even semi-automatically by doing a check on startup and asking the user?)

Project: Advanced stream saving

Brief explanation: Amarok does not offer functionality to save Shoutcast or other streams while listening. Additionally, many songs or mix sets have an introductory part before the part that makes one want to save it so a ring buffer would be a very nice thing to have. It would work like this: -User listens to stream, Amarok starts keeping the last -say- one hour saved to disk, discarding old stream data as new data arrives. -User wants to save the mixset she is listening to ten minutes into the mix. She clicks on "save stream" in the menu and now she is offered a way to choose the beginning of the recording from the past one hour. After choosing a beginning and a file name Amarok starts saving from the chosen time, adding new material as it arrives and is being listened to.

Expected results: Be able to save a stream to listen to it again later without the need to record everything out of fear of losing the beginning of a great song/mix.

Okular

Project: Okular backend

Project Information: Okular has plug-in system that allow it read different documentation formats. It currently reads a range of formats, but there are several that might be able to be improved (e.g. XPS) or implemented.

Brief explanation: The project would need to identify a format that requires improvement (or implementation). Candidates that have been requested in the past include the Microsoft Word (.doc) format and the .lit e-book format. Given a suitable library, potentially any format could be considered. Consider:

  • Microsoft Visio
  • Microsoft Access snapshot (would require implementing a .emf file renderer - not simple, but could be useful in many other places in KDE).

Note that improving PDF requires changes to the poppler library, and you would need significant previous experience with PDF (and ideally with poppler) to make much progress.

Expected results: A working backend, capable of rendering most documents to a readable level.

Knowledge Prerequisite: C++ is pretty much essential, and at least passing knowledge of Qt. C programming experience may be useful for some libraries.

Mentor: Potentially one of several. Contact the okular mailing list.

Other applications

Application User Interface Test System

There are a couple of tools available for Qt / KDE that allow testing of applications - squish and kdexecutor. Both are binary only, and are specific to the systems that they are built on.

It would be useful to have an open source tool that allowed us to test applications in a scripted way. Similar open source tools include Dogtail and LDTP, which use the accessibility interfaces in Gnome.

There are arguments for and against using accessibility - it might be a lot more useful to implement a separate system, using some of the Qt4 specific features including QMetaObject. Qt4 has a nice set of hooks, and QTestLib shows how they can be implemented. However instead of requiring specific code in the application (as done by QTestLib), it would be more flexible to use LD_PRELOAD and a small interface library.

More discussion: Brad Hards <[email protected]>

Usability

The KDE Usability Project is willing to offer support mentoring to one or two projects (more if additional design mentors are available) which involve heavy UI development or UI redesign activities.

Infrastructure

KDE infrastructure tools, like Bugzilla, the Review Board, etc.

KDE dependencies and non-KDE projects

Depending on the relevance of the proposal, the KDE Project will accept student proposals on projects that are not part of KDE, but which are either KDE dependencies or relevant to KDE or the Free Software Desktop.

Qt Cryptographic Architecture

The Qt Cryptographic Architecture (QCA) isn't strictly part of KDE, however it is used in a range of KDE applications (and other applications). A range of projects are possible, in terms of adding security features to applications (e.g. SASL, encrypted content, client side puzzles).

A specific need is the provision of alternative backends, which are typically the interface between QCA and some underlying crypto library. We already have several, but only the OpenSSL one is fairly complete, and OpenSSL is pretty ugly. A new backend would require some previous crypto knowledge, and ability to program in C++ and C. No GUI experience required! We probably only need one good alternative on each platform.

- Alternative backend - GNU crypto libraries: We have a basic backend using libgcrypt, which is mostly working. However a lot of the more interesting capabilities are present in gsasl and GNUtls. Mentor: Brad Hards

- Alternative backend - Mozilla Network Security Services: The Mozilla project has a library that is separately packaged on most Linux systems. It offers a fairly complete alternative to OpenSSL. We have a basic skeleton for NSS, but it only offers a couple of basic crypto primitives. Mentor: Brad Hards

Strigi

Soprano & Nepomuk

D-Bus

  • a named pipe or shared memory transport implementation for win32
  • can QLocalSocket and QSharedMemory (in 4.4) be used?

Other Freedesktop.org initiatives

Notes on editing this page

Before making any modifications, please log in to Techbase. This will help us track who is contributing to the ideas.

When making modifications to existing ideas, please consider whether you're changing it more fundamentally or just superficially. If your changes are substantial, you probably have an entirely new idea. Similarly, if your idea is modified and you feel it no longer reflects your original thought, please split the idea in two, restoring yours.

Please use the talk page if you want to discuss an idea.

Finally, do not delete ideas without a reason for doing so (like, for instance, being contrary to KDE ideals, being completely unrelated to KDE, being unfeasible, etc.) -- you may want to state in the talk page why you removed the idea.

Do not re-add ideas that were removed without discussing first with the developers of the target application.

Retrieved from "https://techbase.kde.org/index.php?title=Projects/Summer_of_Code/2008/Ideas&oldid=21570"