From BlenderWiki

Jump to: navigation, search

GSoC 2016

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 2016 and reviewed by developers. Read below if you are a student or mentor looking for ideas.

10 students were accepted for GSoC 2016 - see the accepted ideas and follow the progress -> here <-

Contacting Us

You can contact us via our bf-committers developers mailing list

Or via IRC: #blendercoders

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

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

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.


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 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.

Getting the big picture

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

Confirmed Ideas

Motion tracking

Variable camera lens focal length support

  • Benefits: Support of zoom shots in Blender’s motion tracking
  • Description: Currently Blender only handles shots with constant focal length, but in practice artists want to have VFX on zoom shots, which is not supported yet.
  • Requirements: Proficient in C++. experience with minimization problems
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin

Finish multi-camera reconstruction

  • Benefits: Increased reconstruction of camera and object motion using witness cameras
  • Description: Even though internally solver API supports reconstruction from multiple cameras, Blender is still only capable of solving shot from a single camera only. This does not give a robust enough solution in certain scenes, and using witness cameras will improve quality of the solution. This project will basically bring support of witness camera support to a Blender’s solver.
  • Requirements: Proficient in C++. experience with structure-from-motion problems
  • Difficulty: High
  • Possible mentors: Sergey Sharybin

Lens distortion estimation and grid calibration

  • Benefits: Lens calibration straight from Blender, no need to use external calibration tools for that, making scene reconstruction more accurate
  • Requirements: Proficient in C++. experience with camera tracking workflow.
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin


Cycles denoiser

  • Benefits: Cycles render times can be drastically reduced by a post-process option to remove noise from the rendering. Good results can be achieved when the rendering is already relatively noise free (500-1000 samples). The denoiser would be a node in the compositor, and requires a special buffer with 'delta' information for speed, UV, etc.
  • Requirements: Proficient in C++. Experience with image processing and rendering pipelines.
  • Difficulty: High
  • Possible mentors: Sergey Sharybin

Cycles network rendering improvements

  • Benefits: Native support of distributed rendering for both final (F12) renders and viewport over the network, increasing interactivity of working with Cycles
  • Requirements: Proficient in C++, experience with rendering pipeline
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin, Martijn Berger
  • Challenges: make Cycles rendering session fully asynchronous, avoid complexity of data serialization/deserialization (some patches around does it in really unreadable way)

Cycles standalone improvements

  • Benefits: Easier interoperability for studios who do not use Blender, but want to use Cycles
  • Requirements: Proficient in C++, CMake. Experience with rendering pipelines.
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin
  • Challenges: improvements in CMake system to make it deliver fully working Cycles (currently some manual poking around is required), do some fixes in GUI application. replace XML-based file format with something more friendly with huge assets.

Cycles memory optimization

  • Benefits: Lower memory consumption by Cycles, allowing render more complex shots
  • Description: This includes various possible ideas of reducing memory footprint, both manual memory control (like, camera space culling) and automatic ones. For example: camera space subdivisions (like OpenSubdiv), use geometry compression, half-float textures, plane culling and so on.
  • Requirements: Proficient C++. Experience with rendering pipelines, production files structure.
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin

Cycles OpenSubdiv support

  • Benefits: Native support of subdivision meshes using OpenSubdiv (or OpenSubdiv-compatible subdivisions from Embree), allowing render beautiful hires meshes without need to tweak anything in the scene.
  • Requirements: Proficient in C++, basic understanding of subdivision meshes
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin

Cycles UDIM support

  • Benefits: Support of industry-requested image-mapping technique/library in Cycles/Blender
  • Requirements: Proficient in C++
  • Difficulty: High
  • Possible mentors: Sergey Sharybin

Cycles full sample anti-aliasing support

  • Benefits: Higher quality of post-processed images rendered with Cycles, especially when using hair and fur.
  • Requirements: Proficient in C++, experience with rendering pipeline in Blender
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin


BVH accelerated weight/vertex paint

  • Benefits: Faster, more accurate painting, improved painting tools.
  • Description: Currently vertex painting uses OpenGL selection which can be problematic,
    skipping faces smaller than a pixel, no access to faces in the brush radius which aren't directly visible - for example.
This project could be coupled with improved tools that take advantage of the improved painting methods.
Features such as
  • splash detection (accidental painting only surfaces very near/far from the brush depth).
  • Mirror support for vertex paint.
  • Requirements: Proficient in C, 3d-math.
  • Difficulty: Hard
  • Possible mentors: Campbell Barton, Anthony Riakiotakis, Bastien Montagne
  • Challenges: Using Blender’s P-BVH tree for all vertex painting involves many changes to weight/vertex painting, efficiently updating VBOs for more efficient redrawing.

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


Sculpting Tools

  • Benefits: Better sculpting tools to give artists more control, help artists by offering better tools.
  • Description: This task can be comprised of multiple sculpting improvements, suggestions (however this is very flexible and can be planned in more detail by the mentor and student).
    • Silhouette brush (ability to deform an object by sketching a new outline).
    • Fill tool (to outline a closed area on the mesh surface which will be turned into a flat surface across the region).
    • Grab brush - option to limit to connected geometry.
    • Optimizations (improved performance for undo and possibly optimize VBO updates).
  • Requirements: Knowledge of C, basic Linear Algebra (possibly OpenGL depending on the scope of the project).
  • Difficulty: Medium
  • Possible mentors: Anthony Riakiotakis, Campbell Barton

Improve Undo Memory Usage for Mesh Data

  • Benefits: Improvements to undo memory use means users will be able to edit detailed meshes more easily.
  • Description: Blender’s edit-mode undo currently stores an entire mesh for each step.
    Blender's generic undo system (Global Undo) compares memory, only storing arrays which differ, however for editing a mesh - adding or deleting a single vertex will cause the data to differ, causing the undo to store a lot of data for each operation.
    Ideally we could efficiently store differences in mesh data in a way thats more efficient and can be re-used between many tools.
  • Requirements: Proficient in C.
  • Difficulty: Hard
  • Possible mentors: Bastien Montagne, Campbell Barton, Lukas Tönne
  • Challenges: For different tools we may have strategies for storing undo steps (modifying custom data such as UV’s, changes to selection, destructive edits).
With the possibility of binary diffing to increase efficiency when destructive edits are made.

Normal Editing Tools

  • Benefits: Exposing this via tools will give artists (especially those working on low poly modeling - assets for games), more control when adjusting shading for their models is common.
  • Description: Blender’s has editable normals currently, but no way for the user to edit them, this project would require the student to write tools to manipulate mesh normals.
  • Requirements: Proficient in C, 3d-math.
  • Difficulty: Medium
  • Possible mentors: Bastien Montagne, Campbell Barton, Howard Trickey

UV Editing Tools

  • Benefits: Improve UV unwrapping workflow, make tasks which are currently tedious easier to accomplish.
  • Description: Blender’s existing UV editor is very capable, however it there are areas for improvement regarding the current tool-set.
This project would include multiple smaller improvements to existing tools as well as some new features, possible examples include:
  • Improved automatic UV layout.
  • Ability to separate UV’s with a UV-rip tool.
  • Path selection (matching the mesh tool).
  • Copy/Paste between UV layers.
  • Improvements to packing (group existing overlapping islands, support for pinning islands).
  • Requirements: Proficient in C, 3d-math.
  • Difficulty: Easy/Medium
  • Possible mentors: Bastien Montagne, Campbell Barton, Howard Trickey

Higher Quality Solidify Modifier

  • Benefits: This makes it a much easier for anyone who is 3D printing to make a solid shell from a mesh without having to manually create the shell.
  • Description: While Blender already has a solidify modifier, this is intended to be fast, for animation and real-time editing, this project would involve writing a modifier that performs more comprehensive computations to create a solid shell from a mesh.
  • Requirements: Proficient in C, 3d-math.
  • Difficulty: Hard
  • Possible mentors: Bastien Montagne, Campbell Barton, Lukas Tönne, Howard Trickey

Improvements for Bezier Curves

  • Benefits: Blender users who do architectural modeling, product modeling, and motion graphics often use Bezier curve objects. This project will provide a better non-destructive workflow for them, allowing more often just keeping the curves as final renderable objects without having to convert them to mesh objects.
  • Description: Some number of improvements to Bezier curve properties, editing, and beveling, likely including: (a) add multiple material slots to curves; (b) more options for extrusion; (c) better UV generation (no stretching); (d) fix distorted 3d beveling at tight corners. More ideas, including CAD-like editing, could be included if these ideas are finished early.
  • Requirements: Proficient in C, 3d-math
  • Difficulty: Medium
  • Possible mentors: Howard Trickey
  • Notes: An archiviz user as prepared a detailed doc describing these improvements and more.
    See: [1]


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.
  • Difficulty: Medium
  • Possible mentors: Bastien Montagne, Campbell Barton, Mitchell Stokes, Jeroen Bakker
  • Notes: Initial work has begun on an exporter, this project may be to write an importer, will need to be re-evaluate closer to GSOC start date.
    See: io_scene_gltf

Various ideas

OpenGL 2D drawing API

  • Benefits: Simplify drawing code and prepare for migration to more modern OpenGL system (or possibly Vulkan).
  • Description: Currently Blender uses deprecated OpenGL immediate-mode for most areas of 2D drawing.
    This project would involve writing an API to abstract away OpenGL calls for the many areas of the code that only do simple 2D drawing.
    We have some previous and ongoing work in this area, so expect more collaboration than writing from scratch.
  • Difficulty: Medium
  • Possible mentors: Campbell Barton, Inês Almeida, Mike Erwin

Mask animation improvements

  • Benefits: Better control of mask interpolation for artists, improved control over 2D mask animation.
  • Description: Currently masks animation is quite limited, basic tools were added however there is a lot of improvement.
  • Requirements: Proficient in C.
  • Difficulty: Medium
  • Possible mentors: Campbell Barton, Sergey Sharybin, Lukas Tönne

Mask editing from compositor and sequencer

  • Benefits: Easier roto workflow in Blender, avoid need to go back-n-forth from Sequencer/Compositor to Image Editor when dealing with masks
  • Requirements: Proficient in C
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin, Campbell Barton, Lukas Tönne

Delete lower for multires modifier

  • Benefits: Brings back old feature of removing lower levels of multires meshes.
  • Requirements: Proficient in C
  • Difficulty: Low
  • Possible mentors: Sergey Sharybin, Lukas Tönne, Bastien Montagne

Sequencer realtime playback

  • Benefits: Make sequencer playback real-time on a setup with a reasonable complexity, avoiding hiccups on strips start/finish
  • Requirements: Proficient in C, experience with non-linear video editing
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin

Improve stand-alone animation player

  • Benefits: Improved usability for animators to preview their work.
  • Description: Blender can run as an animation player already, however this features is very primitive and can use various improvements:
    • Multi-threaded image loading.
    • Frame pre-fetching
    • Improved usability (feedback when settings are changed, on screen key-map display).
  • Requirements: Proficient in C.
  • Difficulty: Easy
  • Possible mentors: Campbell Barton, Inês Almeida

Package Manager (for add-on’s and possibly other resources)

  • Benefits: Users will be able to keep their add-ons up to date, and developers will have a way to send fixes and updates.
This also means developers who sell add-ons via online stores can have a way to update them.
  • Description: Blender can already manage add-ons, however there is no convenient way to update add-ons once installed.
  • Requirements: Proficient in Python.
  • Difficulty: Medium
  • Possible mentors: Campbell Barton, Inês Almeida
  • Notes: We have written some initial design notes on this topic, see: package management design notes.

Improved threadability of Compositor nodes

  • Benefits: Increased interactivity of Compositor
  • Description: Various nodes (Glare, for example) are still single-threaded or requiring full buffer to be ready on input in order to start operation. This reduces interactivity a lot. Using different implementation of those nodes would make them thread-friendly, making user experience much better.
  • Requirements: Proficient in C++, experience with post processing techniques
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin, Lukas Tönne, Jeroen Bakker, Monique Dewanchand

Trackpads, smooth scrolling and multitouch support

  • Benefits: Blender should get cross platform support for modern input devices. Linux and Windows (Surface Pro) are falling behind.
  • Description: Windows, Linux X11 and OS X code (GHOST library) should have same functional level for touch screen events, multi touch, trackpads, tablets + pens. Best case: implement prototype for multitouch event handling in Blender.
  • Requirements: :Linux, proficient in C, C++. Some event system code experience in Linux would be cool
  • Difficulty: Medium
  • Possible mentors: Sergey Sharybin, Ton Roosendaal, Inês Almeida

User Coordinate Spaces (UCS)

  • Benefits: Artists can use this feature to quickly switch between coordinate spaces (a defined position, orientation and scale) allowing a faster and more precise workflow for modellers and, in particular, architects. This is a useful feature for complex models where some of its parts are not aligned with the world's main axis and therefore utilities like the grid, background images for section blueprints and shortcut access (1/3/7) are not possible.
  • Description: Finish the design and implement the User Coordinate Space feature, creating and managing UCSs, grid drawing and background images defined relatively to the UCS. The discussion of this feature can be seen in: BA thread and phabricator task. This project is not to be confused with 'Transform Orientations' that already exist, they are meant to be used in combination.
  • Requirements: Knowledge of C, basic Linear Algebra and aptitude for iterative UI design with users
  • Difficulty: Easy
  • Possible mentors: Campbell Barton, Inês Almeida

Unconfirmed Ideas


  • Benefits:
  • Description:
  • Requirements:
  • Difficulty:
  • Possible mentors:

User Interface

Configuration Splash Screen

  • Description: The current splash screen that appears when opening Blender should be updated to provide quick access to important user preference options. These options should be placed in multiple pages of the splash screen (support for this would have to be added).
  • Benefits: A configuration splash screen would allow users to easily and quickly configure Blender for their needs.
  • Requirements: Proficient in C, experience in interface design; design should be mostly finished when GSOC starts (not necessarily by student, we can ask some artists with UI experience to do this).
  • Difficulty: Easy/Medium
  • Possible mentors: Ton Roosendaal, Campbell Barton
  • Artist/Stakeholders: Jonathan Williamson/Sebastian König (TODO ask them! :) )


Redesigned Font Objects

  • Benefits: Redesigned and recoded font objects would fix old limitations and create a basis for future development.
  • Description: Code and design of Blender's font objects are almost as old as Blender itself. This project would involve recoding and redesigning them.
  • Requirements: Proficient in C, proficient typography knowledge
  • Difficulty: Hard
  • Possible mentors: Campbell Barton, Bastien Montagne

Advanced Snapping Toolset

  • Benefits: A more advanced snapping toolset would help when a high precision is needed for modelling or object placement.
  • Description: Mainly, this project would mean to add more snapping features and rework the snapping UI/workflow. (Proposal)
  • Requirements:
  • Difficulty: Medium
  • Possible mentors: Campbell Barton


Improve Motion Paths

  • Benefits: Currently Motion Paths are slow to calculate resulting in poor usability, completion of this project would make this feature painlessly usable by animators.
  • Description: Refactor MotionPath and Rig evaluation/dependency graph code so that it is possible for motion paths to refresh automatically on bone/object motion. Threaded evaluation will prevent the UI from freezing during evaluation.
  • Requirements: Proficient in C, optimization and cyclic algorithms/dependency graphs, threading
  • Difficulty: Hard
  • Possible mentors: Joshua Leung, Bastien Montagne
  • Artist/Stakeholders: Hjalti Hjálmarsson

Various Ideas

Seamless Nodes

  • Benefits: A review of currently existing material nodes with a game pipeline in mind would result in simpler node setups for game and real-time simulation artists.
  • Description: Work with existing nodes to add a 'Seamless' option where applicable, as well as other needed options for Blender's material system to be compatible with what is expected to export assets to a modern game or VR engine. See this presentation for an overview of current problems and necessary workarounds with material node setups. Compatibility with game engines and Substance Designer should be investigated.
  • Requirements: Knowledge of C/C++
  • Difficulty: Medium
  • Possible mentors: <mentor needed!>
  • Artist/Stakeholders: Aidy Burrows