Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters
13453 Projects Found
Sort by

Incremental build support for the modules driver

intermediate
LLVM Compiler Infrastructure•2026Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

Until recently, explicit module builds were only supported for Clang modules. With the -fmodules-driver mode upstream patch being merged, the community can finally experience explicit builds for both Clang modules discovered through module map files and C++ named modules. However, one of the main advantages of modules is their ability to being cached. Currently, -fmodules-driver does not support this. Therefore, the proposal strives towards an effort to bring forth an efficient, correct and safe filesystem cache. The proposed filesystem cache will enforce strong concurrency control. Once this cache system is fully implemented, the community will be able to use and manage it with existing Clang flags along with -fmodules-driver mode.

cllvmc+++3
Student: Aadarsh Keshri
Code
Proposal

Add HOST-TO-HOST Support on BSD

intermediate
The Libreswan Project•2026Varies175h (Medium)

The host to host ipsec transport mode works on Linux but does not work on any of the BSDs. The problem is a lack of IKE socket bypass , transport mode policies actually catch IKE traffic itself, which causes problems in establishing and tearing down connections. I will add a socket bypass for all three BSD also the API is different on each one. I will fix the SA mode labeling in the PFKEYv2 backend, add proper teardown and on demand testing to the existing test suite, and make sure everything works as expected on FreeBSD, NetBSD, and OpenBSD.

cpythonshell script+10
Student: Amrinder Singh
Code
Proposal

Enabling Checkpoint/Restore of Rootless Containers

intermediate
CRIU•2026Varies175h (Medium)

CRIU currently supports unprivileged checkpoint/restore in limited cases, but rootless containers remain unsupported because they introduce additional challenges around user namespaces, ptrace permissions, seccomp suspension, cgroup handling, and UID/GID mapping. This project aims to add a dedicated rootless-container checkpoint/restore path to CRIU rather than extending the existing --unprivileged mode. The implementation will introduce a user-namespace-aware helper architecture for dump, preserve cgroup state when delegation permits it, correctly capture and restore UID/GID mappings using newuidmap and newgidmap, and establish proper restore ordering for user and mount namespaces. Deliverables include the new rootless-container support path in CRIU, cgroup handling improvements, UID/GID mapping support, expanded rootless zdtm coverage, and documentation for the workflow and limitations.

clinuxassembly+3
Student: Deepak Anand
Code
Proposal

sktime - Interfacing Foundation models

intermediate
German Center for Open Source AI•2026Varies175h (Medium)

sktime provides a unified Python API for time series forecasting, but its support for modern foundation models, large pretrained models capable of zero-shot forecasting, is still maturing. Several high-value models, such as Google TimesFM and IBM TinyTimeMixer, are not yet interfaced in sktime; existing foundation model adapters lack probabilistic output (predict_interval, predict_quantiles), and there is no shared wrapper to reduce the boilerplate cost of adding new models from the Hugging Face Hub. This project directly addresses those gaps. The primary deliverable is one production-ready foundation model adapter fully integrated into sktime's BaseForecaster API, with fit, predict, predict_interval, and predict_quantiles support, CI-passing tests, soft-dependency handling, and a usage tutorial.

pythonpytorchscikit-learn
Student: Vedant Agrawal
Code
Proposal

Porting Chebfun to GNU Octave

intermediate
GNU Octave•2025$3k–$6.6k175h (Medium)

I propose to work on the following project: porting the Chebfun package to GNU Octave. Chebfun is a numerical computation package for MATLAB that provides a framework for representing functions in a symbolic manner using ”Chebyshev technology”, a term coined by the package authors to describe the use of Chebyshev polynomials to represent functions up to machine precision. GNU Octave is supposed to be mostly compatible with MATLAB, so Chebfun should ideally work without change on the former, but there are some slight differences and unimplemented features in Octave that make this difficult. Primarily, the main issue is that Octave’s support for object-oriented programming (classdef) is not as feature complete and as stable as MATLAB’s, which is a major problem since Chebfun is written in classdef. The goal of this project is to port Chebfun to GNU Octave, and to make it work as a dropin replacement for the MATLAB version. Since fixing classdef is not a feasible/recommended goal for a GSoC project, I will instead focus primarily on making the necessary changes to the Chebfun codebase to make it work in Octave. Along the way, I will compile new information about the status of classdef in Octave, and I will share my findings with the Octave developers, and perhaps aid in some changes to the Octave codebase itself.

c++hg
Student: Thomas Kolman
Code
Proposal

Jitsi Meet Speaker Queue Project

intermediate
Jitsi•2024Varies175h (Medium)

The proposal aims to develop the Jitsi Meet Speaker Queue project as part of the Google Summer of Code program. This project focuses on enhancing user experience by introducing a speaker queue feature that efficiently organizes participants ready to engage in discussions while accommodating the moderator’s preferred speaking order adjustment for participants, and maintaining a record of raised hands at the same time. To achieve these objectives, I will undertake several key steps, including the development of a user interface component, implementation of visual cues and indicators, establishment of a queue management system, refinement of the mobile application to encompass identical functionality, creation of comprehensive documentation, conducting rigorous testing, ensuring seamless integration and deployment, and designing an interactive guide. These steps will also serve as my deliverables for the project, which include a user interface component, visual cues and indicators on the UI, a queue management system implemented using React-Redux, a mobile app feature updating, and an interactive guide for the new feature. Overall, the overarching objectives encompass streamlining communication, promoting collaboration, and contributing to open-source sustainability.

javascriptjavaxmpp+5
Student: Mengyuan Liu
Code
Proposal

HumanAI-2024-AI to Improve Analysis Accuracy

advanced
HumanAI•2024Varies350h (Large)

Project: Enhancing Program Evaluation Research by Leveraging AI for Integrated Analysis of Mixed-Methods Data This project aims to leverage advanced data analytics and machine learning techniques to extract actionable insights from both quantitative and qualitative data collected from the survey. I plan to perform data integration, machine learning techniques and data visualizations to improve survey accuracy and efficiency and draw some valuable insights from results. Deliverables: Survey questions Script/code of programs used to determine the survey sample and perform the data weighting procedures on the data file Integrated data set including qualitative and quantitative data Script/code of programs used to preprocess data, select model and optimize for qualitative and quantitative data Visualization Dashboard presenting the analysis results, highlighting key insights for relationships and ease of use by stakeholders A final report including the analysis methodology, findings, predictive factors identified, and advices for stakeholders Open-source Repository including all code and models used in the analysis, along with documentation to enable replication and further research by the community

pythonmachine learningc+++2
Student: Shao Jin
Code
Proposal

Improving FreeBSD User Emulation of the Armv7 Architecture

beginner
QEMU•2023Varies90h (Small)

The proposal is about improving the QEMU emulator for the armv7 architecture on FreeBSD OS, it's goal is to get a simple C++ hello-world program to compile and run inside an armv7 jail hosted on an amd64 machine, using clang. To achieve this, about 32 syscalls need to be implemented for the qemu-bsd-user master branch, they are already implemented in the blitz branch, by the project mentor. The project is to add them to the master branch, perform testing and debugging of any errors, add them in a series of patches, each should pass the code review guidelines set up by QEMU developers. The solution starts by getting a stack trace of the syscalls that the compiler calls when using the blitz build of qemu-bsd-user, then compare them to the ones that succeed when using the master build of the qemu-bsd-user. Having done this, now we know which syscall are already added and those that are not. Now we proceed to add the missing ones, the project plan is included in the proposal. I will be delivering 32 patches to the qemu-devel mailing list, each one corresponding to a missing syscall.

cassemblykvm+4
Student: Kariiem
Code
Proposal

Add Support for renode.io Simulator

intermediate
RTEMS Project•2023Varies175h (Medium)

Renode.io is an open-source software simulator designed specifically for System on Chips (SoC) and Internet of Things (IoT) devices. It allows developers to simulate the behavior of their hardware and software designs before deploying them onto real devices, saving time and resources. Currently, there has been no documentation or testing mechanism on how to use the renode.io simulator for RTEMS. Thus, this project is created to take a look at which BSPs RTEMS have that are compatible to be used in the renode.io simulator, submit a patch to the RTEMS User’s Guide on how to use it on how to run the them on renode.io simulator, and possibly integrate the renode.io simulator into RTEMS testing ecosystem as an opt-in simulator solution.

cpythonembedded systems+5
Student: Muhammad Sulthan Mazaya
Code
Proposal

Improving PostgreSQL Version Support for pgexporter

intermediate
PostgreSQL•2023Varies175h (Medium)

Pgexporter provides Prometheus metrics for PostgreSQL servers which include some core metrics, as well as custom metrics provided by users. The custom metrics are SQL queries that are run by the various servers, which subsequently may have a variety of PostgreSQL versions. If a query has parts of it not supported by a particular such server, then the whole query gets rejected. This proposal aims to solve this issue by enabling users to provide alternatives of the query of a metric along with the minimum PostgreSQL version on which each alternative query’s supported. Thus, whenever a particular server will need to be queried with a custom query, then based on the PostgreSQL version of the server, the corresponding query will be sent to the server, and the response will be formatted in the form of Prometheus metrics. This will greatly benefit both the users, as well as developers, to provide an out-of-the-box solution and would neither require the updation of codebases to cater to new PostgreSQL major version releases, nor would require the users to adapt to that change.

cpostgresqlperl+8
Student: resyfer
Code
Proposal

Adding features to Thunar file manager

intermediate
Xfce•2022Varies175h (Medium)

Thunar is a light-weight file manager under the XFCE project, written in C and GTK3. While functional and fast, it lacks some useful features present in other file managers, such as undo-redo, file counts for folders, and pictures specific maximized thumbnail view. This project aims to implement these features and add them to Thunar.

cpythonjavascript+2
Student: Pratyaksh Gautam
Code
Proposal

SAGA2 engine

intermediate
ScummVM•2021Varies175h (Medium)

<p>Create a new engine to support Faery Tale Adventure II: Halls of the Dead by The Dreamers Guild.</p>

openglc++assembly+5
Student: a-yyg
Code
Proposal

Awesome Demo Game Project

intermediate
Catrobat•2019Varies175h (Medium)

<p>An old-school survival game made using Pocket Code IDE and Tested on the Android Architecture. The basic gameplay is made up of different levels linked together in a forest, through which the player has to survive all the obstacles &amp; enemies present to make progress. Each level has an unique design with special terrain elements with added power ups and weapons for the player to choose from. As the user progresses the game morphs itself into higher difficulty levels which houses extra traps and harder enemies to fight through.The goal is clear - Survive whatever The Forest has to throw at you.</p> <p>The game is supposed to be presented as an showcase of the capabilities of the Pocket Code Application. It will serve as a reference to all the wonderful features that can be implemented with ease on the Pocket Code.</p>

javascriptandroidjava+7
Student: Vaibhav Anand
Code
Proposal

Synthesis to repair heap-manipulating programs using Java StarFinder

intermediate
The Java Pathfinder Team•2018Varies175h (Medium)

<p>The state of art of program repair for heap manipulating program has focus on specific properties of bugs, like null pointer dereference. We try to fix programs with pre-condition and post-condition written in separation logic. Given a program, we first run JSF to collect its post-state(p) by symbolic execution with the given pre-condition. Then we check if p entails the given post-condition(p'). If not, a bug is detected. Our approach to program repair has two main components: abduction and repair specification inference. First, we propose to infer the missing information to establish the post-condition through abduction using an existing solver. In particular, we infer a constraint f such that p * f is satisfied and p * f |-&gt; p'. Secondly, based on abduction, we symbolically execute the input program with the abduction in a backward manner in order to construct repair specifications at every line of the input program. These repair specifications help to infer valid Hoare-style triples with fix candidates.</p>

androidjavadistributed systems+3
Student: Guolong Zheng
Code

CarbonFootprint API

intermediate
AOSSIE - Australian Open Source Software Innovation and Education•2017Varies175h (Medium)

<p>CarbonFootprint is a great initiative to make people aware of their unnoticed contributions to the degradation of this planet. This initiative needs to be expanded to reach out to a much more wider audience. Thus creating an API for this project can help achieve this task. Modern smart devices can make use of this interface to create new possibilities and information which I think can surely benefit the planet in some way.</p>

scalaandroid/iosjavascript/html/css+8
Student: Rohit Gupta
Code
Proposal

Improving the state of Optim.jl

advanced
NumFOCUS•2016$6k–$13.2k350h (Large)

<p>The purpose of this GSoC project is to work on a variety of loose ends in, and general improvements to, the optimization package <a href="https://github.com/JuliaOpt/Optim.jl" target="_blank">Optim.jl</a>. Optim.jl is written entirely in the <a href="https://github.com/JuliaLang/julia" target="_blank">Julia Language</a>, and organized under the <a href="https://github.com/JuliaOpt/" target="_blank">JuliaOpt</a> organization. Improvements are in the form of a unified documentation effort, performance tests, improved algorithms, unit tests, and general bug fixing. At the end of GSoC Optim.jl should be a relatively well-polished, documented, and tested package for optimization in Julia.</p>

pythonjavascriptr+3
Student: pkofod
Code
Proposal

Reactive and Adaptive Path Planning Using Sensor Feedback and Operator Input

beginner
Open Source Robotics Foundation•2016Varies90h (Small)

<p>ROS path planners such as MoveIt! and Descartes are good at finding feasible robot paths that avoid obstacles and optimize motion. In some applications, adjustments to nominal paths must be made based on sensor feedback or operator input. The issues were raised at ROSCON 2015 . The specific application driving this need is robotic assembly using end-effector force feedback, where parts such as computer board components need placement in holes or sockets with tight clearances, and the object locations may vary considerably with a need to locate them using vision systems. Achieving reactive and adaptive path planning may require extensions to several parts of ROS and ROS-Industrial, including the MoveIt! or Descartes path planners, the ROS control layer, or the Simple Message protocol to hardware robot controllers. Development can take place without actual force sensors or cameras, using simulated sources of the high-level outputs of these sensors in terms of small adjustments that affect the trajectories. The key software objective is to put in place a method to adjust trajectories after they have been nominally planned, rather than focusing on sensor processing.</p>

rosgazebopython+3
Student: Kentaro Wada
Code

Improving UI-Elements

intermediate
Scilab Enterprises•2016Varies175h (Medium)

<p>Scilab being a software used worldwide, needs to focus on how its users (potential developers) interact with Scilab and how comfortable they are with using the features provided by Scilab. Scilab already incorporates the facility to make figures such as tables labels etc and allows insertion and manipulation of data. Unfortunately even though the facility is provided the features have been found buggy and not well documented making its usage very limited and which incapacitates the current users and fails to attract new users .There are some most wanted features like spreadsheets, progress bar etc which are not present and are highly wished for by the users of Scilab,and others.</p> <p>My aim is to improve/upgrade the already existing facility to such a level that the users become very comfortable using it and to further introduce much needed user interface elements in Scilab User Interface Control to make it most favoured software. My work starts with modifying and documenting Uitables and Uitrees and extends upto incorporating ProgressBar. These development would solve major issues with GUI,would attract more users to Scilab and would help in retaining already existing users</p>

cjavac+++2
Student: Rishubh Jain
Code
Proposal

RenAIssance: Automating transcription of historical documents with weighted CRNN and LLM integration

intermediate
HumanAI•2026Varies175h (Medium)

This project will focus on applying hybrid end-to-end models that combine weighted convolutional-recurrent architectures (CNN-RNN) with large language models (LLMs) to recognize text from Spanish printed sources dating back to the seventeenth century. The ultimate goal is to create a user-friendly application that allows researchers to generate transcripts simply by uploading images in PDF or PNG format.

pythonmachine learningc+++2
Student: SaarthakGupta
Code
Proposal

Enhancing AI Primitives in Neovim

beginner
Neovim•2025Varies90h (Small)

Neovim currently lacks built-in support for AI features. As a result, plugin developers need to reimplement the same core functionalities again and again. This leads to duplication and inconsistencies in the plugin ecosystem. This project aims to introduce AI-friendly primitives to streamline AI plugin development. It should add support for inline completion, buffer status indicators, a standardized progress API, and enhance prompt buffers with multiline support to be more friendly toward building AI-assisted workflows. These improvements should make it easy to integrate AI capabilities in Neovim while keeping Neovim performant, lightweight, and extensible as always.

cpythonjavascript+4
Student: Shadman Saleh
Code
Proposal

Implementing Multi-page Folio Support in OpenAFS Linux Kernel Module

advanced
OpenAFS•2025Varies350h (Large)

This project enhances the OpenAFS Linux kernel module with multi-page folio support, addressing a key performance limitation in the current implementation. OpenAFS currently interacts with the Linux kernel's memory management system through single-page operations, despite recent kernel versions offering folio APIs capable of managing multiple contiguous pages as a single unit. I will implement comprehensive multi-page folio support in OpenAFS by modifying key components of the cache manager, particularly focusing on the VFS interface layer where the largest performance benefits can be realized. The implementation will optimize read and write paths to efficiently handle larger memory regions while maintaining backward compatibility with older kernel versions through autoconf detection and conditional compilation. By the end of the project, I will deliver: (1) A complete implementation of multi-page folio support that improves performance, especially for sequential read operations common in application deployment; (2) A comprehensive testing framework verifying functionality across multiple kernel versions; (3) Detailed performance benchmarks demonstrating throughput and resource utilization improvements; and (4) Thorough documentation of implementation details to facilitate future maintenance. All code will be submitted as incremental, well-structured patches adhering to OpenAFS coding standards.

cpythongit+4
Student: Sushil Pandey
Code

"Support display of images from Panoramax in iD"

intermediate
OpenStreetMap•2024Varies175h (Medium)

Panoramax would make a priceless addition to the OpenStreetMap (and FOSS in general) community: the panoramic view feature improves map exploration and gives users access to 360-degree imagery that enhances the mapping process and gives important visual context. Live images can provide a lot of information that can be hard to determine, such as the weather or the terrain condition (like the snow level on ski slopes) and 360-degree are always breathtaking if taken in nature-filled and/or hard to reach places, like summit peaks or seashores. Milestones: 1. Understand how to implement the images, talk to the Panoramax team to get the most out of it and get familiar with the environment 2. Design how to add Panoramax in iD, understand how the image retrieval works and how to best implement it. 3. Get Coding! Write the new Panoramax page in iD 4. Write documentation, write tests, fix bugs and check if all is correctly implemented.

javascriptjavaopengl+10
Student: Mattia Pezzotti
Code
Proposal

RSS Support Add-on in Plone 6

beginner
Plone Foundation•2024Varies90h (Small)

The project enhances Plone 6 by integrating Really Simple Syndication (RSS) support through two key components: exposing Plone content as RSS feeds and embedding external RSS feeds within Plone. A new rss_feed content type with a listing block, provided by the backend rss-provider add-on, and the express middleware in volto-rss-provider enable users to share Plone content as RSS feeds. The volto-rss-receiver add-on, which relies on the rss_mixer_data endpoint from the rss-receiver backend, supports efficient retrieval and display of external RSS feeds within Plone. This project simplifies content syndication and broadens the reach of Plone content, enhancing user engagement and accessibility.

pythonjavascriptrest+4
Student: Ziming Yuan
Code
Proposal

Enhance KomaMRI.jl GPU Support

advanced
The Julia Language•2024Varies350h (Large)

KomaMRI.jl is a Julia package for Magnetic Resonance Imaging (MRI) simulation focused on speed and extensibility. Like other MRI simulators, it solves the Bloch equations, for which the solution can be parallelized due to the independent spin property of the system. Although KomaMRI currently has built-in support for GPU and CPU parallelization, GPU support is CUDA-based and could be extended to work with different GPU backends. In addition, writing GPU kernels tailored for the solution implementation could significantly improve performance compared with the current array-based approach. The goals for this project are to update the KomaMRI.jl package to support Metal, AMD, and OneAPI-based GPU backends, and create a new BlochKernel simulation method which is fully kernel-based and optimized. If time permits, the use of MPI.jl and Distributed.jl to run MRI simulations across multiple nodes and GPUs will also be explored.

cjavascriptc+++12
Student: Ryan Kierulf
Code
Proposal
Showing 5977 - 6000 of 13453 Projects
248249250251252
Proposal
Proposal
Proposal