GSoC is a program sponsored by Google to get students started with Open Source software development.

Read more about the project in the official page.

This page collects potential ideas and mentors for student projects. The ideas are up to date for the Summer of 2018 and reviewed by developers. Read below if you are a student or mentor looking for ideas.

Contacting Us

You can contact us via our bf-committers developers mailing list or on Blender developers discourse.

Or via IRC: irc.freenode.net #blendercoders

You can also use our wiki.blender.org to write down proposal drafts in your personal space.

For matters you prefer to discuss in private, mail Ton Roosendaal: ton at blender.org.

General information for students and (potential) mentors

The list below provides ideas for projects that:

a student coder can complete in 12 weeks (not too easy, and not too hard);

implements topics marked as "to do" by current developers, implements a commonly agreed upon feature requested from our user community, or improves upon existing code within its original goal.

Choosing an idea from this list is not mandatory. Students are free to submit their own proposals or modified versions of the ideas from this page.

Mentors:

A mentor should be someone with Blender coding experience, who can guide a student during all stages of the work, from design to implementation.

Please add new ideas to the "Unconfirmed list". People who have mentored students in the past years can review ideas and mark them 'confirmed'. We will discuss this in our irc channel when needed.

Students:

Students who wish to apply should firstly read carefully the instructions on the Google website to check if all the conditions to participate are met.

If by some reason you can not participate or are not a student, your contribution (outside of the program) is still welcome!
Feel free to take, discuss and develop ideas from the page without any time restrictions.

If you are new to Blender, take some time to connect with the community, the mentors and ask more about the ideas you are interested in.
Then, the next step would be to get familiar with the development environment by compiling Blender on your computer and experimenting with the areas you are interested in.
None of these steps are a hard requirement, but it helps to get your proposal accepted if you show interest beforehand and that you understand your task and can make changes in Blender's code.

We especially invite students to contribute based on their past experience and competencies, or based on their current research, so that they can efficiently bring a new development direction for Blender.

Nearly all projects will require a strong working knowledge of C/C++, in addition we use Python for much of our interface code (anyone skilled in C/C++ can trivially learn enough Python to make the needed interface code changes). While C++ is present in many of the libraries we use, all of them use a C interface when accessed from within the Blender core code.
An exception to this are projects where only Python is required.

More information for Students, a FAQ and Application Template

Getting the big picture

A good illustration of projects we do for Blender you can find on many places at blender.org and our wiki. For example check on:

Confirmed Ideas

Motion tracking

Cycles

Physically Based Hair Shader

Benefits: A modern, physically based, easy to use hair shader for Cycles.
Description: Port the PBRT implementation of the A Practical and Controllable Hair and Fur Model for Production Path Tracing paper to Cycles.
- Port over code to the Cycles kernel, so that it works on both CPU and GPU, conforms to code style, etc.
- Create BSDFs and shader nodes to expose it in the user interface.
- Create tests to verify that the shader is working correctly, conserving energy, etc.
- Benchmark and improve performance.
Requirements: Proficient in C/C++ programming, basic familiarity with physically based rendering algorithms
Difficulty: hard
Possible mentors: Brecht Van Lommel

Volume Rendering

Benefits: Optimized rendering of volume datasets created by Blender or other software.
Description: Implement two or three of these improvements, each is individually useful.
- Tiled 3D image storage and sampling support in the Cycles kernel, to reduce memory usage.
- Direct reading of OpenVDB files as a Cycles 3D image, to render volumes generated by other software.
- Volume motion blur rendering (medium/advanced depending on the algorithm)
Requirements: Proficient in C/C++ programming, familiarity with image processing algorithms
Difficulty: medium
Possible mentors: Brecht Van Lommel

Many Light Sampling

Benefits: Optimized rendering for many lights.
Description: Implement many light importance sampling (paper). There is likely not be enough time for a complete implementation, so plan to do it progressively. For example:
- Build BVH over all lamps in the scene, based on position bounds only
- Use orientation information in the light tree
- Better light importance estimation for textured lights
- Investigate balancing importance with background and portal lights
- Volume rendering support
Requirements: Some experience with rendering algorithms, math for computer graphics
Difficult: hard
Possible mentors: Brecht Van Lommel

Interoperability

Fast Import / Export for selected formats

Benefits: For very large models (millions of vertices), the Python importers and exporters in Blender can take a long time (minutes). Moving some parts of those into C modules could reduce the time to seconds. Doing some simple formats as a GSoC project could pave the way for future developers to tackle the more complex formats.

Description: Speed up import and export of the PLY and STL formats. Both of those are simple formats. Write C modules (that can load with Python inside Blender) to do the slow parts of importing and exporting (likely: file reading/writing and the parsing/formatting of raw text).
See D2835 for how C modules can be incorporated into Blender.
Note that PLY and STL we selected because they are relatively simple and good candidates for this project. Other formats may benefit from this too.

Requirements: Proficient in C and Python programming, familiarity with 3d concepts

Difficulty: medium

Possible mentors: Howard Trickey, Campbell Barton

Import/Export support for glTF File Format

Benefits: Web developers working on 3D projects will have a viable format for loading skinned meshes (animated characters for example).
Description: glTF is a new, open format intended for exporter designed to be used with web technologies, since X3D and other formats were not designed with support skinned meshes in mind.
Difficulty: Medium
Possible mentors: Bastien Montagne, Mitchell Stokes, Jeroen Bakker, Mike Erwin
Notes: There are currently two exporters and a work in progress importer for glTF. This project would be looking at ways to either integrate these tools, or find ways to make them faster and more reliable. This project would likely have a lot of overlap with the "Fast Import/Export for Selected Formats" idea above.
See: glTF-Blender-Exporter, blendergltf (Exporter), gltf-blender-importer

Testing

Tests for Core Libraries

Benefits: Improve development process so changes to Blender's core libraries so further development can be validated.

Description: There are multiple libraries in Blender which could have improved test automation. These include:
- BlenLib (BLI) low level libraries for data structures, math and filepath handling (some areas are already well tested).
- BMesh: Mesh editing operations (subdivide, split edges, recalculate normals.. etc).
- ImBuf: 2D image library (scaling, rotation, color operations).
- Developers note, feel free to other areas.

Requirements: Proficient in C programming.

Difficulty: easy/medium/hard (depends a lot on the areas tested)

Possible mentors: Campbell Barton, Bastien Montagne, Howard Trickey

Tests for Regressions

Benefits: Quickly detect if fixes and new features break existing functionality.

Description: This would involve using Python to automate detecting changes to Blenders behavior, by comparing the result from operations in new Blender versions and a reference version, similar to the system Cycles uses. Some areas that would be good to test:
- Mesh modifiers:
  - Write or improve scripts to compare mesh vertices, topology, data layers.
  - Create test infrastructure to save and compare meshes to a reference version.
  - Visualize failed tests on a HTML page (example)
  - Create tests for all modifiers with a script by applying them one by one to a test mesh in a .blend.
  - More extensively test different modifier settings.
- Compositor
  - Make a good set of input test images, with different alpha, channels, HDR colors, etc.
  - Compare resulting images for all compositing nodes with various settings.
- Object/Bone constraints:
  - Similar to meshes, could compare object/bone transforms or rendered images.
- Operators (hard)
  - Record operators in Blender and then replay them in a test
  - This would work best for operators that have an easily testable input/output, comparison code from above areas could be reused.
  - Operators that need a UI would be challenging, but could be useful to test e.g. painting or sculpting.
- Feel free to propose other areas.

Requirements: Proficient in Python programming.

Difficulty: easy/medium/hard (depends a lot on the areas tested)

Possible mentors: Campbell Barton, Bastien Montagne, Brecht Van Lommel

Modeling

Bevel Improvements

Benefits: Add some user-requested enhancements to modeling with Bevel tool and modifier

Description: There are a number of possible enhancements, improvements, and bug fixes for Bevel described in task T48583. A good project would be to select some of these that could be done in the GSoC timeframe. One possible set:
- User-drawn profiles. There would be some UI work to get a widget for capturing the profile, or perhaps a separate object could be used (clunkier). And then work on how to do the edges with that profile (fairly easy), and how to do the corners with that profile (fairly hard). If the profiles aren't symmetric, then a solution for figuring out the orientation of the profile on each edge needs to be found.
- Harden normals option. There is the possibility in Blender now to have custom normals on face corners around a vertex. This can be used to make the faces adjacent to a bevel shade perfectly flat. This is not easy because the internal rules about which normals can be controlled independently are more complex than you might think.

Requirements: Proficient in C programming, familiarity with 3d concepts and operations on vectors

Difficulty: medium

Possible mentors: Howard Trickey

Boolean modifier improvements

Benefits: Boolean modifier which just works!
Description: The current boolean modifier in Blender fails in real case scenarios.
Requirements: Proficient in C, 3d-math
Difficulty: High
Possible mentors: Bastien Montagne, Sergey Sharybin
Challenges: BMesh based boolean modifier currently doesn't support: self-intersecting shapes, exactly overlapping geometry and zero (or near zero) length edges in faces, see T47030.

Painting

Finishing PTex support in Blender

Benefits: PTex support for both painting in Blender and rendering in Cycles.
Description: There was work done during 2015 which ended up in initial integration of PTex into Blender, but it was not finished and needs polishing, workflow simplifications and code quality improvements.
Requirements: Proficient in C++
Difficulty: High
Possible mentors: Sergey Sharybin

Layer painting

Benefits: Bring the painting pipeline closer to within Blender
Requirements: Proficient in C
Difficulty: High
Possible mentors: Bastien Montagne
Challenges: There is no robust multi-layer image support in Blender apart from multi-layer EXR. Adding such support is to be part of this project.

Unconfirmed Ideas

Template

Benefits:
Description:
Requirements:
Difficulty:
Possible mentors:

Dev:Ref/GoogleSummerOfCode/2018/Ideas

目次