Google's Summer of Code 2024

Django is a mentor organization for the 2024 Google Summer of Code. Read ​Google's page for more information on how the program works.

Django's GSoC program is being coordinated by the Natalia Bidart and Thibaud Colas.


If you're interested in mentoring -- supervising a student in work on Django-related activities -- let us know via the Mentoring topic on


Student application period runs until April 2, 2024.

If you'd like to get started on your proposal early, we'll be looking for a few things.

  • You'll need to have a concrete task in mind (some ideas are below) along with a solid idea of what will constitute "success" (you tell us).
  • If your proposal is a single large feature, library or site, you'll need to present a detailed design specification. This proposal should be posted to the Django Forum, where it can be refined until it is accepted by the developer community.
  • We'll want to know a bit about you -- links to previous work are great, if any. If you're proposing something ambitious, you'll need to convince us that you're up to the task.
  • You'll also need to provide us with a schedule, including a detailed work breakdown and major milestones so your mentor can know if and when to nag you :)

Here's an example of an accepted proposal from a previous year:

Note that none of the ideas below are good enough to be submissions in their own right (so don't copy and paste)! We'll want to know not just what you want to do but how you plan to pull it off.

Don't feel limited to the ideas below -- if you've got a cool project you want to work on, we'll probably be able to find you a mentor. We plan on approving as many projects as we possibly can.

We're accepting any GSOC proposal that fits one of the following three categories:

  • Work on Django itself - such as the ORM, forms, etc. This is what we've traditionally accepted GSoC entries in.
  • Work on tools to support Django - the issue tracker dashboard ( is a good example of an existing tool that would have fit into this category.
  • Work on libraries that supplement or add new features to Django to ease development - django-stubs and Django Debug Toolbar are good examples of existing projects that would have fit here.

Unless explicitly mentioned below, we're not looking for people to work on existing third-party libraries - we aren't able to guarantee commit access to them. We may allow an exception if a maintainer of the library in question agrees to help mentor beforehand.

The broadening in scope is to allow people to work on new ideas to help Django development and developers without tying you down to having to implement it in the core codebase (and thus ruling out some projects that might otherwise be useful).

We're still going to be strict with what we accept - you'll need to provide a strong use case for your idea and show that it would be useful to a majority of developers or significantly improve the development of Django itself.

We're not looking for small groups of incremental updates - like "improve Django's Trac" - nor are we looking for impossible tasks, like "replace Trac with this brand new issue tracker I'm writing". What you propose should be a single project, achievable within the time period of GSoC, and something the core developers can help mentor you on.

We're also not looking for sites or projects that are merely written in Django — this GSoC is not for you to propose your new forum hosting site or amazing Django-based blogging engine.

Note that when you contribute code, you will be expected to adhere to the same contribution guidelines as any other code contributor. This means you will be expected to provide extensive tests and documentation for any feature you add, you will be expected to participate in discussion on django-developers and the Django Forum when your topic of interest is raised. If you're not already familiar with Django's contribution guidelines, now would be a good time to read them - even if you're not applying to work on Django core directly, we'll still want the same level of contribution.

How can I improve my chances of being accepted?

The best thing you can do to improve your chances to be accepted as a Django GSoC student is to start contributing now. Read up on Django’s contribution documentation and make yourself known to the other contributors by your contributions (ideally, related to the area of your proposal). That way, when it comes time to evaluate student applications, you’ll be a known individual and more likely to be able to get the attention you need to develop a proposal.

We're looking for candidates who can demonstrate that they can engage in work of a project scope on an independent basis. We're there to help but we can't watch you every step of the way, so we need to see that motivation from you. Being active before the submissions process is the best way to demonstrate this.


All GSOC-related communication is handled via the Django Forum, in the Mentoring channel. Any proposals for GSOC should be submitted there, as well as discussion on the proposed projects and any updates that students post.

Please be careful to keep content to the forum clear and purposeful; if you have an idea, update, or criticism, please make sure you describe it in detail; it can be tedious asking people to clarify any vague statements.


Here are some suggestions for projects students may want to propose (please feel free add to this list!). This isn't by any means the be-all and end-all of ideas; please feel free to submit proposals for things not on this list. Remember, we'd much prefer that you posted a draft proposal and your rough timeline / success conditions to the the Django Forum, in the Mentoring channel or django-developers list, even if it's already on the list below; it will help you get feedback on choosing the right part of a problem, as well as helping to see if there is any interest before you start drafting a full proposal.

When developing your proposal, try to scope ideas/proposals to size of your project (175hrs or 350hrs) -- you need to be ambitious, but not too ambitious. The GSoC does not cover activities other than coding, so certain ideas ("Write a more detailed tutorial" or "Create demonstration screencasts") are not suitable for inclusion here.

On the other side, though, be sure to be concrete in your proposal. We'll want to know what your goals are, and how you plan to accomplish them.

The project ideas below list key skill, but all assume a knowledge of Python, and familiarity with Django itself.

In no particular order:

Auto-importing shell

Difficulty Medium
Size 175hrs
Potential Mentors TBC
Key Skills Management commands

One of the most popular features of django-extensions is shell_plus, which is like shell but auto-imports your models for you. Adding this behaviour to core would be a great addition.

A proposal should consider ways to define extra things to import, perhaps a documented path of subclassing the management command and overriding a method.

Expected outcome would be a PR adding this to Django.

Security: Bring CORS and CSP into core

Difficulty Medium
Size 350hrs
Potential Mentors TBC
Key Skills HTTP request-response cycle, middleware, decorators

There are third-party apps providing support for Cross-Origin Resource Sharing (CORS) django-cors-headers and Content Security Policy (CSP) django-csp, but it would be good to have support built-in to core.

Following the design of the CSRF/clickjacking protection, having safe defaults, and allowing straightforward per-path customisation, via e.g. decorators, would improve the security of all Django projects.

Outcome would be a pair of PRs adding these into Django.

Auto-detection of custom migration operations

Difficulty Hard.
Size 350hrs
Potential Mentors Mariusz Felisiak
Key Skills Migrations Framework

Allow auto-detection of custom migration operations.

The auto-detector has its change-detection mostly hard-coded:

It doesn't seem easy (or even possible with the current approach) to allow third-party code to intervene. The list of handlers to generated the individual operations would need to be data-driven, so that custom steps could be added.

Expected outcome here would be a PR allowing auto-detection of custom migration operations.

Improve the Database Cache Backend

Difficulty Medium.
Size 350hrs
Potential Mentors TBC
Key Skills Cache Framework

Setting up a shared cache backend is nearly always required, as many third-party packages assume the cache works like this (unlike the default locmemcache which is per process). DatabaseCache is the easiest such cache backend, not requiring any extra infra and working on shared hosts without a filesystem. But it could be better.

Django-Mysql has had a much better DB cache backend implementation since 2015: . This has never been adapted for the other supported databases but it should be fairly straightforward, mostly some translation of SQL to different dialects.

Expected outcome would be a PR improvement database cache backend.

As a stretch goal, it would also be nice to hook the database cache tables into migrations somehow rather than the current hacky duck typing approach: ).

Expand django-stubs coverage

Difficulty Hard.
Size Variable
Potential Mentors Adam Johnson
Key Skills Python typing and Django-stubs

django-stubs is an external project that adds type hints to Django. It may be possible to work on it under GSoC if you can show experience with Python’s type hints and Mypy.

django-stubs uses Mypy’s stubtest tool to check that its type hints align with Django’s source, per its contributing documentation. The “todo” list contains ~1600 functions and classes missing type hints. A proposal targeting a specific, significant subset of the missing types is likely to be accepted.

Configurable Content Type Parsing

Difficulty Medium.
Size 350hrs
Potential Mentors TBC
Key Skills HTTP request-response cycle

For Django 5.0 we're looking to modernize the HTTPRequest object, adding a content-type aware property. This will parse request.body according to the content type.

The initial phase — targeted for before GSoC — will add and add support for JSON body handling, but the next phase is to make that fully pluggable with custom parsers.

  • Add a list of parsers to the request object, that can be customised — in a middleware for example — at any point prior to accessing
  • Parsers should implement a can_handle(content_type) -> Bool method. The first parser returning True will be selected to parse the request.body.

Expected outcome is a PR allowing configurable content type parsing.

Add Async Support to Django Debug Toolbar

Difficulty Medium.
Size 350hr
Possible mentors Tim Schilling
Key Skills asyncio, ASGI & Channels, and django-debug-toolbar

Django Debug Toolbar (DDT) is one of the key packages in the Django ecosystem.

DDT is not yet compatibile with Django Channels and async Django run unders ASGI. Adding support for async to DDT would be a great contribution.

Preliminary implementation ideas for this are available here:

Would require some knowledge of asyncio, Django Channels, ASGI, and how the Django Debug Toolbar works.

Expected outcome would be a PR (or multiple PRs) moving the toolbar towards full compatibility with Django channels and async logic.

Or Create Your Own

We have around 900 accepted tickets on Django. Browse the issue tracker by component — here's an example filter for contrib.staticfiles. What's the bit of the framework that interests you? What contribution do you want to make to it?

Use the tickets as guides here. Remember the advice above, that your project needs to be both on Django itself here, and achievable in the timescale of GSoC.

Could be scoped as a 175hr or a 350hr project, depending on your idea.

Possible mentors: Natalia Bidart, Thibaud Colas.

We're open to all good ideas!

Last modified 3 months ago Last modified on Mar 15, 2024, 3:15:37 PM
Note: See TracWiki for help on using the wiki.
Back to Top