Summer of Code/GSoC Ideas 2016

If you'd like to get involved in ScummVM - or one of our sister projects, such as ResidualVM - we'd love to help you get started!

We've had a lot of successful student projects as part of Google's Summer of Code in previous years -- we hope to inspire you to work with us and (hopefully) add your own success.

For any work on ScummVM, you'll probably need to already be comfortable with a basic level of C++. Some of the tasks might need more specialised knowledge (for example, working with ResidualVM may need you to understand some OpenGL and 3D math); we give our thoughts about this alongside each suggested task, below.

Most importantly, we'd like you to join our community. There are many previous GSoC participants who are still involved in our project, and whether or not you participate as part of Summer of Code, we'd love for you to get involved too.

You should come to our IRC Channel and introduce yourself! We're friendly, and it's often the easiest way to ask questions about the tasks and the code in general. The channel is the main form of everyday communication for the project, and there will almost always be developers there who can discuss your project ideas, answer questions and help out.

You can find more information about what we expect from you before you apply at GSoC Application.

Introduction

We have a list of potential tasks further down on this page, but before you look at them, perhaps you'd like to take a look at some of the successful projects from previous years! We encourage all of our students to maintain a blog during their summer work, which is a nice way to get some sense of what they accomplished.

One popular type of task is to improve our support for the games you love, whether this means a new game engine, or helping us to perfect an existing one.

Sometimes source code is available - in recent summers, students integrated code supporting games such as Sfinx (blog), The Prince and the Coward (blog) and Avalanche into ScummVM. In fact, our support for the Wintermute engine was not only started by a GSoC student (blog), who integrated the code into our tree, but also drastically improved by another student a year later (blog).

A more challenging (but hopefully rewarding) idea is to start (or continue) reverse engineering a game where no source is available. Two good examples are the pair of students who drastically improved ResidualVM's support for Escape from Monkey Island (blog, blog), and the work on improving Operation Stealth (blog). Another option is to work on merging (and improving) someone else's reverse engineering work, such as was done with the ZVision engine (blog).

If you'd prefer to improve ScummVM more directly, there are even more options available there; in the past, students have (to give some examples) improved our OpenGL support, added a testing framework (blog), improved our scaler code (blog), written a new GUI framework, added loadable modules for embedded platforms (blog), rearchitected our keyboard input code (blog) and added support for high-colour (16bpp and above) graphics. It's difficult for us to imagine ScummVM as it was before some of these projects, you can make a huge difference!

Tasks

General contacts: Our IRC channel, our mailing list, or contact Eugene Sandulenko, John Willis, Arnaud Boutonné, Johannes Schickel

The ideas here are meant to be just that - ideas. We hope they help inspire your proposals, but you should also consider suggesting your own completely new project ideas. Pick something you really want to see improved/fixed, and come and talk to us about it!

If you're looking for more inspiration for ideas, beware of our TODO (and the other TODO lists linked from there) and our OpenTasks pages. Many of the tasks listed there might be incomplete or outdated, or too difficult for a new developer. The best thing to do is to come and talk to us!

GUI Tasks

Our current GUI could use refreshing and updating, in particular to improve how it works with newer platforms such as iOS or Android. We have a few suggested tasks:

Improve touchscreen GUI

Technical contacts: Eugene Sandulenko.

Difficulty level: Easy (code) / medium (architecture). You'll need a touchscreen device which can run ScummVM, to test on.

Our launcher/options GUI has been designed for keyboard/mouse input, and does not work well in practice on modern touchscreen devices.

Since it is theme based, part of the problem can be resolved by using a custom theme. However, our GUI code will need extensions to allow it to behave like a proper touchscreen application. See OpenTasks/Generic/Touch GUI for more details.

Improve Main GUI

Technical contacts: Eugene Sandulenko.

Difficulty level: Easy.

We have a wishlist for improved GUI widgets; we'd like better sliders, multiline text widgets, an improved list widget, and better widgets for PopUps.

Also, several years ago, we switched to a new XML-based and vector-based GUI, but unfortunately during this transition number of nice touches were lost. In particular, the current GUI lacks soft shadows and antialiasing in number of places. We'd like them back! At the same time, it would be nice to add support for transparent PNG files.

Finally, it would be nice to have support for a scalable GUI which looks good at modern resolutions, which would require changes to our theme format, among other improvements.

See OpenTasks/Generic/Improve GUI Look for more details.

Game Tasks

Technical contacts: Our IRC channel, our mailing list, or contact Eugene Sandulenko, John Willis, Arnaud Boutonné, Filippos Karapetis,

If you already have reverse engineering experience, you could consider working on one of the external in-development game engines, or even on support for a new game. However, doing this kind of work is very difficult and time-consuming - you would have to convince us that you have the necessary skills to actually be sufficiently productive, probably by demonstrating some actual progress first.

If you don't feel quite up to that level of challenge, we have lots of other suggestions:

Macromedia Director

Technical contacts: Fuzzie

Difficulty level: Medium. You'll need a reasonable level of programming experience, and probably some Director games.

Many 90s-era adventure games were developed using the Macromedia (now Adobe) Director tool. It would be nice to be able to play these games in ScummVM! We have Python code available which can parse and display the contents of Director 2 and Director 3 'movie' files. This should be enough to implement a ScummVM engine to allow some early Director adventures to be played; for example, parsing the movie files, implementing the frame-based playback system, drawing bitmaps and shapes, playing sounds and running some basic (Lingo) scripting.

Port WebVenture engine

Technical contacts: John Willis, Filippos Karapetis.

Difficulty level: Medium. You'll need to understand JavaScript, as well as a good level of C++.

It would be great to support games which were written for the MacVenture engine from ICOM Simulations. It was used in the late 80s and in the early 90s for 4 games. The MacVenture games are still available for purchase from Zojoi.

The WebVenture engine by Sean Kasun is a reimplementation of this engine, so we (hopefully) already know enough about how it works. Of course, the current code is written in JavaScript, which means we can't use it directly; a new engine needs to be written (in C++) and integrated into ScummVM.

Wintermute 3D

Technical contacts: Einar Johan Trøan Sømåen, Paweł Kołodziejski

Difficulty level: Medium/hard. You'll need to be able to understand 3D graphics, and rearchitecture/design the relevant parts of the engine.

In 2012, support for games using the Wintermute engine was merged into ScummVM, but it still lacks support for games which use 3D graphics. It would be great to be able to play these games in ResidualVM!

See Wintermute 3D for more details.

In Cold Blood engine refactor

Technical contacts: Einar Johan Trøan Sømåen, Paweł Kołodziejski, Joost Peters

Difficulty level: Medium/hard. You'll need to be able to understand rearchitecture/design the relevant parts of the engine.

ResidualVM project. See ICB engine refactor for more details

Improve SCI support

Technical contacts: TBD (talk to us on IRC, or send an e-mail)

Difficulty level: Hard. Good C++ knowledge and some knowledge of x86 assembly.

ScummVM has stable support for the older Sierra SCI games, but the newer ones -- such as Space Quest 6, Quest for Glory 4, Gabriel Knight 1 -- still need extensive work. As this is also something we are very actively working on ourselves, please come talk to us if you would be interested in helping out with reverse engineering and re-implementation.

Infrastructure Tasks

Finally, there's always plenty of other practical tasks on our wishlist!

Improve Android port

Technical contacts: Fuzzie

Difficulty level: Medium/hard. You'll need some knowledge of C++, Java and ideally Android development and OpenGL. Access to at least one Android device is probably also necessary.

Our current Android port is in need of improvement, especially combined with modern versions of Android. We'd like to improve the GUI and the input code in particular, but hopefully you also have your own ideas if you've tried the port (if you haven't: do so!). There are some patches already available, and it should be possible to merge code from other projects (such as SDL 2). A native configuration GUI could also be an option.

Improve audio device configuration

Technical contact: Johannes Schickel.

Difficulty level: Medium. You'll need enough C++ experience and knowledge to design a suitable solution.

Our configuration currently doesn't support all the audio and MIDI options we would like, and even common configurations cannot always be conveniently specified.

See OpenTasks/Audio/Audio Output Selection and OpenTasks/Audio/MIDI Device Configuration for more discussion and some technical details of two possible tasks in this direction.

Hardware accelerated blitting

Technical contacts: preferably Johannes Schickel, otherwise Einar Johan Trøan Sømåen, Alyssa Milburn or David G. Turner

Difficulty level: Medium. Some knowledge of graphics APIs (ideally OpenGL) would help, and ideally a mobile device of some kind which can run ScummVM, to experiment with.

Some engines (such as Wintermute and Broken Sword 2.5) would greatly benefit from hardware acceleration for their graphics code. Since this is not possible for all ports, an important part of this work would be developing a suitable API.

See OpenTasks/Graphics/Hardware Acceleration for more details.

Native OS X port

Technical contacts: Einar Johan Trøan Sømåen, Paweł Kołodziejski.

Difficulty level: Medium. You'll need to know C++ and Objective C (and ideally have some Cocoa experience), and have a Mac.

ScummVM's current OS X port is based on SDL 1.2, which is a dead project (having been replaced by SDL2); this means that the current state of the OS X port seems to degrade with each new OS X release. Also, functionality added in newer releases of OS X (such as the new full-screen modes introduced in 10.7) are not available for use in ScummVM.

One option for solving this would be to create a backend for OS X that doesn't use SDL. This would mean writing/porting replacement code for the parts where SDL currently handles things (i.e. at least audio, video and input, and ideally other details too). Preferably, such a project would be to retain backwards compatibility with 10.2 as we have today, while also allowing for a good user experience on the very latest OS X versions.

Text to speech

Technical contacts: Our IRC channel, our mailing list, or contact Arnaud Boutonné or Thierry Crozat

We have two suggested tasks in the direction of text-to-speech:

Adding text-to-speech support in Mortville Manor

Difficulty: Easy (depending on how you want to approach the task); just knowledge of C++ and some experience programming should suffice.

The original Mortville Manor game used a speech synthesis system based on PC Speaker.

Our hope for this task would be to replace this obsolete speech synthesis with an external dependency which would allow the implementation of modern text-to-speech generation, in (at least) French, German and English. We have some ideas for which libraries would be suitable, but we're also open to suggestions (and offering the option of platform-specific APIs is also a possibility).

Adding speech synthesis of on-screen text for people with reduced sight or for learning to read

Difficulty: Medium. You'll need to be comfortable enough with C++ to be able to (quickly) understand enough of the existing engine code in order to add this functionality.

Using the same library used in the previous task, it would be nice to have similar text-to-speech generation for other games. The challenge here would (hopefully) be to add the necessary interfaces for providing the text, and any needed other information (such as timing), to individual game engines. Part of your preparatory work would be working out (with our help) which engines to target.

This task would allow people suffering from sight issues to play more games in ScummVM, and it could also be very useful to help people who are learning to read.

Alternatively (or additionally), you could consider adding other accessibility features.

Cloud integration

Technical contacts: TBD (talk to us on IRC, or send an e-mail)

Difficulty: Medium. You'll need to know some C++ to be able to tweak with our launcher and you'll eventually have to pick up knowledge about the API/SDK of the selected cloud service(s).

The idea is to have cloud integration in our launcher, so the user doesn't have to manually copy his/her save files between his/her devices. The more providers (Dropbox/OneDrive/Google Drive/etc.) we support, the better. The implementation would look something like this on the UI: The user clicks on the Options button in the launcher and goes to the 'Cloud' tab, where he/she can configure his/her accounts. Then he/she does it in all of his/her devices, and ScummVM (and the selected cloud service) should handle the rest without any user interaction.

You will need to add an extra tab to the Options menu where the user can configure his/her cloud account and specify a path where ScummVM should look for saved games. You will have to come up with all the implementation details since they will heavily depend on the cloud service(s) you choose to support (preferably at least two).