Project ideas for internship programs

Table of Contents

This page is shared for events such as Google Summer of Code or similar internship programs which GIMP might participate in, as a list of project ideas for participants. You may choose to implement exactly one of the proposed ideas, propose new ideas inspired from this list, or suggest completely new projects (which is perfectly fine if your proposition makes sense). Our roadmaps may also be a good source of inspiration.

You will be selected on the quality of the proposal and on your attitude within the context of a Free Software Community. Also we prefer smaller projects which end up in our main codebase, rather than over-ambitious projects which you won’t have time to finish and might end bitrotting for years.

Please also read the main page on internship programs with GIMP.

Robust OpenCL operations

Category
GEGL, OpenCL, hardware acceleration
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Jehan, Øyvind
Difficulty
Intermediate
Outcome
Reviewing and fixing existing or writing new OpenCL implementations of GEGL ops

Wikipedia defines OpenCL as: “OpenCL (Open Computing Language) is a framework for writing programs that execute across heterogeneous platforms consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs) and other processors or hardware accelerators.”

The GEGL engine has had OpenCL alternative implementations for many operations, and it was enabled by default at some point. Unfortunately it proved unreliable, sometimes with slower processing, wrong rendering or even crashes.

It would be extremely worthwhile to test all existing implementations, debug and improve them. Unit-testing in GEGL repo to compare OpenCL and “standard” implementations of a same operation would definitely be a huge plus too.

Additionally adding more OpenCL implementations would be a good bonus.

The main goal of this project is: robustness. No need to get GPU or other hardware acceleration if the result is wrong or if it crashes GIMP. We want to be confident in the quality of the code in order to re-enable OpenCL acceleration by default.

See the list of opened bug reports with “OpenCL” label.

Implement In-Painting Tool

Category
User Interface, Core, Tools, GEGL
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Jehan, CmykStudent
Difficulty
Intermediate
Outcome
implementation of the tool in GIMP codebase

GIMP has had support for in-painting (filling in an area based on the surrounding image) for many years with the third-party Resythesizer plug-in. There have been many requests to implement the feature as a tool directly in core GIMP. In addition to this algorithm, there is also the GEGL operation alpha-inpaint which works similarly.

Relevant discussions that would assist with implementing this feature can be found here and here.

  • Study the Resynthesizer plug-in, gegl:alpha-inpaint operation, and other implementations
  • Design a potential implementation and UI
  • Improve the implementation of the algorithms as needed
  • Implement the tool

Improving unit testing

Category
Unit testing
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Jehan, Jacob
Difficulty
Intermediate
Outcome
Improved unit testing infrastructure and new unit tests

Currently GIMP unit testing framework is really outdated, adding new tests is complex and therefore never happens. We should specify and code a proper framework for testing GIMP features.

This implies automated tests we can run in our Continuous Integration in Gitlab and not interactive tools (though such tools can be interesting too, as additional process, if someone has something nice to propose).

  • Port existing tests to the new framework;
  • Testing all libgimp functions;
  • Testing GEGL operations implemented within GIMP codebase;
  • Testing plug-ins (in priority the file import/export ones, but not only);
  • Testing core code;
  • Testing GUI code if possible;
  • Writing down the procedure to add unit tests to make it a mandatory process in future development.

Improving the text tool

Category
GEGL, color science
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Liam Quin
Difficulty
Intermediate
Outcome
Improvement of the text tool

Our text tool is a bit of a UI and UX mess and deserves a proper rewrite/enhancement project:

  • Re-specify text editing and formating as well as the tool option, for existing features, but also adding new features for modern text editing (see also this draft);
  • Add OpenType support.

Implement GEGL operations for GIMP

Category
GEGL, image processing
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Jehan, Øyvind
Difficulty
Intermediate
Outcome
implementation or improvements of GEGL operations in GIMP or GEGL codebase

The migration of GIMP to use GEGL has accelerated - for some GIMP functionality the main hurdle to migrate is having GEGL ops that can act as drop in replacement for the core processing functionality (some ops would be desired directly in GIMP others could likely go directly into GEGL).

For most code involved, porting to GEGL involves understanding what the current code does; and port or reimplement it as a floating point processing operation (floating point math often ends up shorter and more readable than the 8bit equivalents.

There are also some filters which were ported to GEGL, but some people prefer the old one (e.g. the Sharpen filter). It would be worth investigating the difference and either implement the old one or improve the new one.

Talk to us for specifics on which operations would be a good project`.

Implement OpenColorIO Color Management

Category
User Interface, Core, Tools, GEGL
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
drc, CmykStudent
Difficulty
Intermediate
Outcome
implementation of the OCIO color management system in GIMP codebase

GIMP uses industry standard ICC Color profiles to allow users to match and maintain colors for image editing and printing. The film industry utilizes a separate standard, OpenColorIO, which focuses more on manipulating colors in a space rather than trying to keep them consistent across multiple devices.

This project would involve adding support for OCIO color management in addition to the existing system. This addition would improve user workflows for motion picture and animation work, as well as improve compatibility with other OCIO-supporting software like Blender and Krita. The project would involve the following:

  • Research OCIO and color management systems in general
  • Design and test a user interface
  • Implement the code

Improve Non-Destructive Editing

Category
GEGL, User Interface
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Jehan, CmykStudent
Difficulty
Intermediate
Outcome
implementation of the feature in GIMP codebase

As of version 3.0, GIMP now has initial support for non-destructive editing with layer effects. Yet there is much more work to be done. Our roadmap provides some ideas for the next areas to improve, or you can propose your own:

  • Studying the current implementation
  • Design improvements to UI or functionality
  • Implement the improvements

Improving off-canvas editing

Category
User Interface, Core
Project size (GSoC)
Large (350 hours)
Skills
C
Possible mentors
Jehan
Difficulty
Intermediate
Outcome
implementation of the feature in GIMP codebase

GIMP recently got the ability to view the image out of the canvas. This is still incomplete. Among the many possible improvements:

  • Being able to select off-canvas.
  • Being able to see off-canvas but with an effect (e.g. dimming).
  • Having various tools and features working differently when “Show All” is enabled.

Extension website

Category
Web
Project size (GSoC)
Large (350 hours)
Skills
HTML, Javascript and other web technologies
Possible mentors
Jehan
Difficulty
Intermediate
Outcome
New website and build scripts for continuous integration

We would want a website for our future extension platform, with very specific criteria. Apart from some necessary dynamic parts, we want a website as static as possible, with generated pages when possible. GIMP is a software project, which relies on community. We don’t want to spend all our time having to maintain and manage a website with a lot of moving parts. So we need simplicity first, security first, with just the right amount of dynamicity.

See this document for an early overview of what we are looking for.

Convert gimp-help build system from autotools to meson

Category
gimp-help, build system
Project size (GSoC)
Large (350 hours)
Skills
Python, some understanding of autotools and Makefiles
Possible mentors
Jacob
Difficulty
Intermediate
Outcome
The gimp-help repository can be built using meson

More and more projects move from autotools to meson for building. GIMP itself already uses meson as main build system. We would want all targets in our autotools build converted to meson. The main ones being able to build html for all languages, validate the xml files, create the distribution packages, making pdf quickreference guides, etc.

Some guidelines for porting from autotools to meson can be found here, and more Gnome specific here.

The build system needs to function on Linux, Windows and Mac. This would need to be integrated in our CI builds. There is an almost 2 year old repository where some work was done, but we ran into some problems due to the more strict directory and other requirements of meson. However, there have been improvements to meson which may make it easier now.

It is possible that you may have to write a meson module like the gnome one, which has functions for handling yelp, gtkdoc, etc. Don’t forget to check out the i18n module, you may be able to use that too.