Skip to main content

Notice: This Wiki is now read only and edits are no longer possible. Please see: for the plan.

Jump to: navigation, search

Google Summer of Code 2017 Ideas

Project team member and potential mentors, add your content here. The format suggested below is just an idea. Play with the layout, but please don't mess with content provided by other projects. Please be sure to follow branding guidelines (e.g. "Eclipse Dash", not "Dash"). Putting things in alphabetical order seems like a fair thing to do. Links to content hosted elsewhere are fine, but bear in mind that this page will likely be the main point of contact for people who are not already inside your community.

Eclipse 4diac

4diac is an environment for modelling and executing distributed real-time industrial control applications utilizing the modelling language defined in IEC 61499. For that 4diac provides as its two main components the Eclipse-based 4diac-ide as development and device management tool and an execution environment called FORTE for executing the models on embedded control devices.

Here are some of our project ideas:

  • Generate documentation pages out of model components. In 4diac the main component elements already hold quite some information. However to find out what a component is doing and what it can be used for is quite hard. Similar to Java doc or Doxygen it would be great to generate HTML files for our model components based on the already available information.
  • Mylyn integration for 4diac models
  • Generation of Unit-test code out of the component specification

Eclipse ChemClipse

ChemClipse is a tool for chromatography/mass spectrometry. The combination of chromatography/mass spectrometry is often used in the area of forensics, for quality control as well as for life sciences. Chemical data is best suited to be used in combination with machine learning and statistics. Moreover, when it comes to machine learning, script languages like Python or R play a major role. Hence, we will have a look how to efficiently combine chemistry, machine learning and scripting as part of the GSoC initiative.

Here are some of our project ideas:

Eclipse Dash

NOTE that this is basically a placeholder to give mentors an idea of how they might format a section of their own. This may actually survive as an idea to present to students, but--by way of expectation management--expect that it will disappear.

Eclipse Dash is a place where the community itself can collaborate on tools for community awareness and collaboration in support of our ultimate objective of committer quality and cooperation. This is very much a research project as we are not entirely sure what these tools will be.

Here are some of our project ideas:

  • Extend the Eclipse Dash Gently Dependency analysis tools to identify the use of third-party JavaScript libraries bug 509617
  • Update the IP cartoons and move them to the handbook bug 498290


Capra is a traceability management tool that enables creation, maintenance and visualisation of traceability links between arbitrary development artifacts such as requirements, design models, code, task tickets and so on. Since Capra is a product of a research and academia project, there are lots of interesting features that students could implement. Please browse on the list of features here, but the following have a high priority and we encourage students to look at these:

  • Analyse the traceability models and create visual representations of issues, traceability statistics and so on. See Bug 510492
  • Add collaboration features to the tool. See Bug 506906

Eclipse RDF4J

For more information about this project, contact the project team via their mailing list.

Eclipse RDF4J is a framework for scalable processing of linked data in RDF. This includes parsing, writing, scalable database storage, reasoning and querying (using the SPARQL query language). RDF4J offers a set of Java libraries as well as a fully-fledged database server and several client UI tools to interact with RDF data. We're a small team who are open to fresh ideas and new contributions. People interested in doing a project with RDF4J are invited to browse through our issue tracker and look for anything marked "help wanted", or to submit their own proposal.

Here are some project ideas:

  • Extend the SPARQL QueryRenderer utility to support more advanced SPARQL 1.1 features (subqueries, aggregates, etc.) #496
  • Extend/replace the SPARQL QueryBuilder to a more user-friendly API and allowing more advanced SPARQL 1.1 features #71
  • Add support for the SHACL (Shapes Constraint Language), a declarative language for specifying data validation constraints on RDF database #743


EASE allows to add scripting functionality to the Eclipse IDE. By providing script source locations we read script code and make it available in the UI. Such scripts may use special header keywords that trigger certain actions.

Dependency keyword

By introducing a new keyword for plugin dependencies, scripts could aid the user to install required components before run. A detailed description is given in Bug 511525.

Script location resolvers

We use parsers to fetch scripts from the file system or the workspace. A prototype for an http index file parser is available, too. It would be great to have parsers for source control systems like github, gerrit or svn to fetch scripts directly from such locations. See Bug 511528 Bug 511529 Bug 511530 for details.

Dynamic Dialogs

The UI module of EASE allows to open/close views and to display some basic dialogs. For user scripts it would be interesting to create custom dialogs to query for user input. Such dialogs would typically be forms based. This task is about developing an interface to dynamically create UI dialogs with user defined content. There should be support for text input, checkboxes, radio buttons and file/folder selections.

The programming part of this task might be small, however we expect a clear and simple API here, so API development would be the main task here. The API should be simple and intuitive. It is not intended to copy the SWT API in the scripting layer.

If you are interested in this topic you should provide an abstract of the planned API on the mailing list before applying for GSoC.

Validation builder for script files

The mechanism of loading modules provides some new features to script languages. As we derive modules and functions from java classes we know about their syntax, expected parameters or deprecation annotations. We also have access to java classes and can check for their availability. Target for this topic is to provide a builder that verifies these parts of scripts and provides error/warning markers to workspace files.

If you are interested in this assignment you should have some experience in EASE scripting and its module mechanism. Further knowledge on Java reflection would be required.

EMF Forms goes AngularJS: A generic editor framework for the web

EMF Forms is an Eclipse framework to efficiently develop form-based UIs (see It also provides a renderer for web applications called “JSON Forms”. JSON Forms transfers the concepts of EMF and EMF Forms to a JSON Schema and AngularJS based web stack. EMF Forms provides a generic editor component, which makes it very efficient to create editors a given data model. This is often used for the creation of developer tooling. However, it is bound to SWT and XML. The goal of this project is to provide this generic editor framework on the web stack of EMF Forms, too (JSON Forms). Instead of EMF and XML, it will consume a JSON Schema and a JSON file as input/output. This component would enable the efficient creations editors for the web based on a given JSON Schema and therefore support the development of tooling for platforms such as Eclipse Che or Orion.

  • Possible mentor: Maximilian Koegel
  • Interested student: Lucas Koehler


The Eclipse APP4MC project provides a platform for automotive tooling based on AUTOSAR compliant models and focuses on developments for multi and many core systems. A basic set of tools is available to support different design steps not only limited to the automotive domain. APP4MC therefore includes:

  • A basis for the integration of various tools into a consistent and comprehensive tool chain
  • Extensive models for timing behaviour, software, hardware, constraints descriptions etc. (used for simulation, analysis, and data exchange)
  • Tools for automatic software parallelisation i.e. for optimising multi- and many-core architectures
  • Examples, documentations, workflows, and more

A4MCAR: Multi-core Demonstrator

A4MCAR (project idea I) is a remote controlled electric demonstrative car that will not only be equipped with a multi-core microcontroller for actuation and sensing (real time tasks), but also with a Raspberry Pi 3 in order to address more complex applications such as image processing, web server streaming, and touchscreen UI interactions. APP4MC will be used for both low-level and high-level modelling including runnables, processes, and threads of the whole system for an accurate and precise system analysis. The student's efforts could address:

  • Evaluating recent techniques in multi-core software development for scheduling, partitioning, and optimisation
  • Design of an hardware structure for the A4MCAR
  • Developing low-level drivers for multi-core micro controllers
  • Administration of a Linux-based system on the Raspberry Pi 3 to be able to achieve
    • image processing
    • camera streaming
    • sensor driving
    • core utilization interface on a web server
    • a touchscreen user interface for dynamical core and process management of A4MCAR
  • Researching the kernel-level processes and profiling developed applications on instruction-level on both low-level and high-level controllers
  • Developing necessary scripts to potentially distribute applications/processes given the inputs from APP4MC
  • Modeling the system on APP4MC, based on the findings from profiled applications and evaluating the parallelization outcomes on controllers

Technology overview:

  • Programming languages / technologies such as C, C++ , xC, Python, Bash, GCC, CMake, Linux, PHP, Javascript, HTML

Implementations would be closely related to Rover developments (Polarsys).

Possible mentor: Robert Hoettger, Interested student: Mustafa Ozcelikors

Eclipse CHE: Datasource plugin for Eclipse Che 5

Eclipse CHE is an open source developer workspace server and cloud IDE.

Previously we had a datasource plugin for Che3. See demo

To goal is to rewrite this plugin for Che5.

  • Move the server part to a Che agent
  • Find a replacement to Schema crawler which is LGPL and can't be used in Che
  • Adapt UI
  • Adapt datasource discovery to detect the Che runtime process rather than Docker runner
  • Possible Mentors: Sun Tan
  • Interested Student: Sudaraka Jayathilaka

Eclipse CHE: Java Plug-Ins for code assist/checkers

Eclipse CHE is an open source developer workspace server and cloud IDE.

When people are using an IDE, they may require that the code don't have any issue.

The goal is to add plug-Ins providing Java help. It may include

  • Add support of code recommender in Eclipse Che [1]
  • Add support of SonarLint in Eclipse Che [2]
  • Adapt support of Jacoco in Eclipse Che for code coverage [3]
  • Other tools

Eclipse CHE: Web Development in Eclipse Che

Eclipse CHE is an open source developer workspace server and cloud IDE.

Today, when you edit HTML files in che, the rendering is done in another tab/window of the browser.

The goal of this plug-In is to add a new panel performing the rendering of the application. So, no need to go to another tab/window, just save the file from one panel and the rendering is performed in another panel.

This will allow fastest and incremental development. We could add support for a "tutorial" mode which allow you to navigate in several steps to accomplish the HTML application.

Eclipse CHE: gradle support in Eclipse Che

Eclipse CHE is an open source developer workspace server and cloud IDE.

Today, only javac and maven are supported for Java projects.

The goal is to add plug-In providing the Gradle support [4]

  • like for maven, it should handle code completion and dependency downloads.
  • The idea is to build the support by several steps, the first one having the minimal set to support gradle, and the complete steps would be all support of code completion, dependencies, modules, etc.

Eclipse Kapua: IoT gateway simulation

Eclipse Kapua is a modular IoT cloud platform to manage and integrate devices and their data.

The goal of this project is develop one or more industrial IoT data models and simulate them in a way that they can be integrated into the already existing Kura (IoT gateway) simulator. The idea is to have a simulated data model (like a wind park, a train or anything else) which generates realistic telemetry data and which can be controlled through the cloud solution.

The tasks would be:

  • Define a data model (e.g. wind park)
  • Write a simulation, which runs continuously in either real time or accelerated time
  • Integrate this simulation into the Kura simulation framework
  • Maybe write a Web based UI for controlling the simulation from a different communication channel (e.g. like setting the current weather conditions for the simulation)

Eclipse Kapua: Interactive IoT gateway

Eclipse Kapua is a modular IoT cloud platform to manage and integrate devices and their data.

The idea of this project is to develop a gateway simulation which is fully controllable by some sort of UI (web or rich client). IoT gateways normally forward telemetry data and command and control to some other system or to sensors and actuators. However, every now and then, a "mock" setup is required to test your "on top" application, which is making use of IoT in the end.

For easing this application development, it would be nice to have some sort of gateway, which you (as a human) can use to "fake"/"mock" data. So for example you define a sensor reading and get a UI which allows you (e.g. with a slider) to provide this sensor reading. Of course the simulator should also allow for simulator corner cases like loss of connection or misbehavior.

The tasks would be:

  • Implement a generic data model for providing simulated telemetry data and command and control
  • Write a mock gateway based on the Kura simulation framework feeding data into this data model
  • Write up a user interface (rich client or web based) for updating this data model
  • Providing some easy way of deployment (e.g. docker container)
  • Possible Mentors: Jens Reimann

Eclipse OMR

Eclipse OMR provides reliable C and C++ high performance components (garbage collector, Just In Time compiler, platform porting library, asynchronous event handling, tracing, diagnostics, ...) for building all kinds of language runtimes such as Java, Ruby, Python, Lua, etc. These components were originally distilled and contributed from the IBM J9 Java Virtual Machine and made available for use in other language runtimes. The OMR project also includes a library called JitBuilder, which lets you create a JIT compiler for a new language relatively quickly.

Our ultimate goal is to build an open reusable language runtime foundation for cloud platforms in full cooperation with existing language communities. There are currently OMR based runtimes for Java (IBM J9), CRuby (Ruby+OMR Technology Preview), Lua (Lua Vermelha), Smalltalk (SOM++ with OMR), Rosie Pattern Language, Base9 (an ultra simple runtime for workshop-based learning about the OMR JitBuilder library).

Here are some of our project ideas :

  • Port a (subset of a) new language or runtime to use OMR (e.g. Python,R, Julia, make a suggestion!) using the JitBuilder library
  • Use JitBuilder to dynamically compile native code to accelerate some application (e.g. Apache Spark, NumPy/SciPy, or make a suggestion!)
  • Implement a general/dynamic object model. The object model should support Javascript and Ruby.
  • Valgrind support for the Garbage Collector and JIT memory
  • Port JitBuilder interface to another language (e.g. Ruby, Python, make a suggestion!)
    • Java bindings exist so you can write Java code to dynamically generate native code callable as a JNI method
    • similar model could be applied to another language or possibly using SWIG to make JitBuilder accessible from more languages
  • Port OMR to a new hardware platform (e.g. ARM64)
  • Enhance Intel processor vector instruction support in the OMR compiler
    • add support for 256- and 512-wide vector data types and enhance JitBuilder interface to handle different width data
    • showcase with JIT compiled vectorized code!

Back to the top