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.
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 (blog) 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!
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!
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
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.
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:
Technical contacts: Sev
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 a WIP engine in ScummVM tree, but it requires much more work in order to implement all hundreds of Lingo commands.
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!
ResidualVM project. 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 the relevant parts of the engine.
ResidualVM project. See ICB engine refactor for more details
Mission Supernova games
Technical contacts: Sev
Difficulty level: Medium. Knowledge of German language would be a help
There were several adventure games by Steffen Dingel, which are freeware now: http://outpost.simplicity.de/ Among them were Mission Supernova and Mission Supernova 2.
We got hold of the original source code written in C with some x86 assembler. We need to rewrite these in a portable C++ and add support both Missions in one engine. If possible, a translation of the game texts into English, or developing tools for performing such translation could be a great advantage.
Technical contacts: Sev
Difficulty level: Medium/Hard
SLUDGE is an engine and adventure game development environment, developed by Hungry Software, and open sourced in 2008. It has number of games created with it. The goal of this project is to port the Engine to ScummVM, so games, made with SLUDGE, could be run.
Bring your own Adventure or RPG
Technical contacts: Talk to us on IRC, or send us an email.
Difficulty: Hard. You'll need good knowledge of C++, as well as knowledge of (reading) assembly.
Our project consists of re-implementations of classic games, and we have listed
a number of potential new game engines that you could work on here on our ideas
page. However, you may have a classic 2D Adventure game or Role Playing Game
(RPG) you are interested in yourself that is suitable for ScummVM that you
would like to reverse engineer and re-implement. If so, great!
Adding a completely new game engine is not easy, and you will have to convince
us that you are aware of the challenges involved, that the game you are
interested in is feasible, and that you have the necessary skills. Preferably,
you will already have done some preliminary investigation, into for example
data file formats, disassembly, etc.
Please come talk to us to see if we have a mentor who would be interested in
working with you on such a game. We'd be happy to help out.
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.
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.
Game packaging system
Technical contacts: Sev
ScummVM offers 8 freeware games for download, but they need to be downloaded and installed manually. It would be great to develop a universal system which would let us descibe a game, e.g. provide screenshots, game descriptions, metadata, and package it for different platforms, so we could put them to different applicaiton distribution systems.
Examples are: Linux packages, Google Play, Apple App Store, Steam, ForgeTV store, and anything beyond that.
Support for shaders and arbitrary scalers
Technical contacts: Sev
ScummVM uses software scalers for graphics enhancements. In 2012 we were running GSoC for turning them into plugins. That work needs to be completed, basically, it is just rebasing of the patch. The rebasing was started here: https://github.com/digitall/scummvm/tree/gsoc2012-scalers-cont
Modern systems often have OpenGL with shader support. RetroArch project shaders are standard for them in open source gaming. LordHoto started work on adding support for those to ScummVM. His unfinished work could be found here: https://github.com/lordhoto/scummvm/tree/libretro-shader
We need to add both improvements to our scaler system. Recent PSP2 port already adds some basics for scalers, particularly in GUI, so that could be reused too.
We need to have it tested on desktops and at least Android, but preferably also Windows and iOS.
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.
Technical contacts: our SCI team; talk to us on IRC, or send an e-mail
Difficulty: Medium. You'll need to know or learn about SCI internals.
We're in the process of reverse engineering modern SCI games (SCI32 games, from the generation of Gabriel Knight 1, Quest for Glory 4, Space Quest 6, etc.). For testing and debugging purposes, having access to good tools to study data files, resources, scripts, and run-time behaviour can be very useful. A number of such tools already exist, including some of our own tools, tools from FreeSCI which need porting to ScummVM, and a few external tools. You may identify gaps in the currently available tools, and in discussion with our SCI development team, propose ways of improving or integrating these tools, with the goal of making it easier to develop support in ScummVM for SCI32 games.