From BlenderWiki

Jump to: navigation, search

Accepted applications for 2009

Google Summer of Code 2009 at Blender

General Information

Student applications for Google Summer of Code (GSOC) are accepted by Google from March 23 until April 3. See the Summer of Code FAQ's page referenced at the end of this document.

In order to be accepted for a Google Summer of Code (GSoC) grant, your proposal must really stand out. Student applications are submitted at the Google Summer of Code website:

Important! We ask that you follow our application template when writing your proposal:

Requirements for acceptance

  • You must be able to work on your Summer of Code project full time for the summer (i.e., we will favour applicants who have no summer school or full time job elsewhere);
  • You must be thoroughly proficient in C. Some projects may be based in C++ or python, so you should be proficient in those languages if you intend to use them.
  • You must currently be a user of some 3D graphics program, with a strong knowledge of 3D concepts. All other things being equal, preference will be given to Blender users who have good knowledge of many of the program's features;
  • You must be willing to submit weekly progress reports and be available for weekly IRC meetings;
  • All short listed candidates will undergo a brief interview on IRC;
  • Preference will be given to those who can successfully compile Blender from source on their preferred platform.

Requirements for successfully completing a Summer of Code project

  • Complete all of the goals set out in your Summer of Code application;
  • Complete a weekly status report each Friday;
  • Attend a weekly development IRC meeting on Sundays, 16:00 CEST (14:00 GMT, 10:00 EST, 07:00 PST, 01:00 AEDT) -- some exceptions may be made for people who are unable to make the meeting time;
  • Don't be late with work, reports, etc -- failure to do so may lead to early dismissal from the program;
  • Keep up regular communication with your mentor -- failure to do so may lead to early dismissal from the program.

Project Ideas

The following list provides some ideas for projects that

1) a student coder can complete in the time frame given (hopefully not too easy, and not too hard); and

2) either implement a coveted feature request from our user community, or improve upon existing code.

Applicants are also welcome to choose a project of their own design that implements a feature they wish Blender had.

We especially invite students to contribute based on their past experience and competences, or based on their current research, so that they can efficiently bring in new development directions for blender.

Be warned though, some areas of the code are scheduled for dramatic architectural changes and are beyond the scope of a Summer of Code project. With this in mind, it may be prudent for an applicant to pass ideas around on the developer's mailinglist before investing a lot of time on a proposal (see link below).

Additional project ideas may be added to this list, so you may want to check this page later as the application deadline looms.

Please note that proposals that have been merely cut and paste from this list of project ideas with little value added will be swiftly discarded.

Blender 2.5 project

General info about 2.5:

  • API-fy Blender code.
    Blender's internal code is being transformed to use RNA (data acccess) Operators (for UI level tools) and lower level "data ops" API calls which also need to be exposed to the Python scripting language. Students can help migrating code for this system and implement and validate the Python API for it.
  • Re-implement existing Python scripts.
    By using the new RNA and Operator API, and the currently being developed "data ops API" we need to re-implement our existing set of importers and exporters and helper tools.
  • Custom editors (advanced)
    Blender 2.5 supports an extension to allow fully customized but well integrated editors. Only the very basics for this exists now, and will require an architectural (on Python + C level) design first.
  • Cocoa 64 bits port for OSX Ghost library
    Note: one of the core team members expressed interest to do it. But maybe he likes to do something else :)


  • Improve and optimize Blender's Raytrace intersection acceleration structure. It is currently using an octree, previous research has experimented with BIH, KD-tree, BVH, but were never finished.
    Blender dev note: the requirements for such a system are very high, supporting everything current system offers, and better. Experiments with hybrid approaches could be welcome too. Also support for "bucketing" or "multires LOD" is relevant for the future. I'd advise to only accept students here with proven experience with this technology. (ton)
                 DONE! in GSOC 2009 raytrace aceleration proyect.
  • Color Management. Implement and document a system to do color management in Blender. This involves adding support for doing various color space conversion, and integrating them in areas such as the renderer, sequencer, image window display, .. . Specifically, importing and exporting images in various color spaces, color proofing, etc should be possible. Ease of use and documentation are important. Some experience in this area is recommended.
    Blender dev note: This proposal is too vague and undefined for anyone who's not totally comfortable with Blender's rendering system. More-over, a really good color space system directly relates to how shading/lighting in Blender works now, which is one of the topics we want to redesign fully. Would be more efficient if the redesign was clear first. (ton)
                      Color Man. Partially done by Matt?? (2009)


  • Improve blender for dealing with motion capture data (imported from BVH files).
    Features such as curve simplification for motion capture data (with curve fitting), Improve the process or re-targeting one rig to another and turn repetitive motion capture animations into loops.
  • Integrate Bullet physics in animation system (advanced)
    Blender needs a Rigid Body "construction kit", allowing visual editing in 3d for constraints (hinges) and fully interactive forces feedback. Important is to check on well defined or future-proof integration with other physics systems in Blender as well. Biggest issue is that it requires a very good design on UI and interaction level first.
  • Integrate Fluid-sim based Smoke simulation
    Blender already has Fluid simulation from Nils Thuery. He (with other scientists) improved this with Smoke simulation.


  • OpenGL Rendering Performance improvement in the viewport. Blender currently uses immediate mode for rendering, while vertex arrays, VBO's and display lists could dramatically improve performance. OpenGL experience recommended.
  • NURBS. The previous summer of code NURBS project integrating Nurbana is in a working state. This project would extend on that project, various directions are possible: support vertex/edge/face selections modes and associated tools like mesh, or add new tools like trim/fillet/blend, or improve modifier stack integration and add useful NURBS modifiers.
  • Boolean improvements. Using more types model such as NURBS, Meta or particles along with a better system for mesh models. Multiple methods that can be selected for the situation might be useful along with the current one. A method that cuts a hole at intersected edges and then welds edges together similar to a distance based method.
  • High poly modeling optimizations. Flat shading in the 3d view might help as well as using methods that keep the memory and processing needs lower than normal. With even small optimizations things should scale up to allow higher polygon capacities.


  • Add support for node plugins. This can be for multiple node systems (materials, compositor, textures...). This means nodes have to be able to work like built-in nodes instead of the user manually having to setup things as for pynodes: registering python or C code to run, defining UI in python.
  • Add an OpenFX ( plugin host to blender's compositor to allow the use of any OFX effects plug-in within a compositor node tree.
  • Create a modifier NodeTree system for deformation. Should include support for vertex weight groups. (advanced).
    Code experience with our "Derived mesh" and "Modifiers" system is a requirement.


  • Non-Traditional Devices: Investigate and implement methods to improve using Blender with devices such as tablets, or multi-touch screens. Particularly this would involve implementing functionality to support this better in the event system, documenting how tools should behave to support them, and working on an area such as the transform system to take better advantage of these devices. Experience or strong interest in user interface design is recommended.
  • Relationship Editor: The OOPS editor is being removed from Blender 2.5. A good relationship visualizer and editor is still a useful future however. A new editor would try to solve the presenting the data with nicer graph layouts that does not look like a big mess, and based on 2.5 technologies it can allow much more powerful editing than the OOPS editor.


  • Improve Collada exporter/importer, making it more stable and correct, and more complete. A set of test files and method to test them should be delivered along with the code to ensure that the importer/exporter can correctly handle them.
    Blender dev note: I'd highly recommend this to any student! (ton)
  • Create an FBX importer to complement the exporter. A set of test files and method to test them should be delivered along with the code to ensure that the importer/exporter can correctly handle them.

Unit Tests

  • Unit Tests: Implement unit tests for a part of Blender functionality. These should then cover all operators and properties of a certain area. Various types of tests such as crash tests, regression tests, correctness tests or performance tests are possible. These should run efficiently and help developers avoid breaking things when refactoring or adding new functionality.

Important Links

  • Project page:
  • Developer's mailinglist:
  • A guide for new developers:
  • Google Summer of Code FAQ's:
  • An example of a successful proposal from 2005:
  • Previous summer of code projects:
  • Thread on forum about 2009 ideas