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

Future-proofing FFmpeg — VVC Decoder Improvements

advanced
FFmpeg•2023Varies

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 →
350h (Large)

Versatile video coding (VVC) is a recent standard for video compression. It is the newest in a line of standards which have proven extremely successful and dominate video coding today. FFmpeg is a project which develops a suite of multimedia libraries used by billions in applications including Google Chrome and VLC. This project improves on FFmpeg's implementation of a VVC decoder FFVVC in two ways: * Its conformance to the VVC specification is improved by implementing esoteric features. * Its performance on x86 systems is improved by the development of hand-written assembly optimisations.

cgitasm+3
Student: Frank Plowman
Code
Proposal

FHIR: Add support for FHIR PATCH operations

intermediate
OpenMRS•2023Varies175h (Medium)

OpenMRS is using the FHIR API more and more in place of the REST API. However, the FHIR API is, by default, quite verbose. Supporting PATCH operations would allow us to support partial updates to FHIR resources without needing to send the whole resource from the client to the server.

javahtml5groovy+11
Student: mherman22
Code
Proposal

VLC iOS UI Update

intermediate
VideoLAN•2023Varies175h (Medium)

This proposal purpose is for an introduction regarding me and my personal experience, and my plan to contribute for VLC, more specifically VLC-ios on it’s UI department. The goals is to catch up with the Android version of VLC in term of User Interface and features.

copenglc+++10
Student: Rizky Maulana
Code
Proposal

Implementation of the Sequence collection specification using the EVA contig alias backend

intermediate
Global Alliance for Genomics and Health•2023Varies175h (Medium)

This project aims at implementing the Sequence Collection specification designed by the Global Alliance for Genomics and Health (GA4GH). The main goals of this project is to make a standardized way to refer to sequence collections as well as providing mechanisms to compare different sequence collections.

pythonjavamongodb+10
Student: Haroune Hassine
Code
Proposal

Arm CCA Support for Unikraft

advanced
Unikraft•2023Varies350h (Large)

This project aims to add Arm Arm Confidential Computing Architecture (CCA) support to the Unikraft ecosystem, which is a step of “Unikraft as the Secure Configurable Unikernel”. Arm CCA is introduced in Arm v9 and it introduces new hardware features to make OS run as a confidential VM without trusting the underlying hypervisor. To achieve this goal, this project needs to finish the following tasks: 1) making CCA an option for Unikraft and adding support for necessary RSI commands; 2) preparing the FVP environment; 3) Adding support for more advanced features like attestation and memory encryption; 4) testing the project using several applications.

cpythonxen+3
Student: Zhang Xingjian
Code
Proposal

Eclipse Vert.x client for Apache Pinot

intermediate
Eclipse Foundation•2023Varies175h (Medium)

Eclipse Vert.x is a toolkit to build reactive applications on the Java virtual machine. It provides asynchronous and non-blocking clients for different types of databases. Apache Pinot is a realtime distributed datastore for analytics workloads. The Apache Pinot Java Client uses AsyncHttpClient as the default transport and is cumbersome to use in Eclipse Vert.x applications. This project proposes to create a vertx-pinot-client extension. This extension will be a lightweight wrapper around the existing Pinot Java client. It will also offer an alternative transport for the client using vertx-web-client. This will make the Apache Pinot more accessible to Vert.x users.

c/c++javageospatial+15
Student: thefallenangel
Code
Proposal

Parameterized device layouts for GF180MCU

intermediate
Free and Open Source Silicon Foundation•2023Varies175h (Medium)

Throughout this project, I hope to gain a firmer understanding of TCL scripting and the backend working of parameterized devices and hopefully make some new ones too these devices are used many times while using magic to makes our work easier. this project will help me in a deeper understanding of how each command in the command line works in magic and how we can make some changes in its scripts to make it to improve user inference. In terms of the project, the goal is to work in scripts to draw devices like LDNMOS, LDPMOS, bipolar transistors, photodiodes, Avalanche Diode, etc as well as fixing a few devices that are known to draw incorrectly for some parameter values.as far as working on this project is concerned as per my own rough timeline following is the methodology i would use while working on the project : The magic VLSI tool uses TCL scripts for the parameterized design layouts so we should start by going through some of the scripts to get a better understanding of what we are working with then we will be going through each of the mentioned devices and study its CMOS design and draw it on the magic tool using the magic command line TCL scripts, we will also be looking at the pre-existing devices to check if we were getting the required drawings of them or not if the drawings are not as required then we will be making changes to those scripts as well, in the meantime, we will be looking for improvements we could make on the user inference of magic tool too. to get a better understanding of how I would work on this project please go through the proposal I have attached below. thankyou soo much for your time, looking forward to working with you soon.

pythonjavascriptfpga+11
Student: Qurrat ul ain Alam
Code

Development of a Modular and Composable Variational Inference and Normalizing Flow Library for Julia

intermediate
The Julia Language•2023Varies175h (Medium)

We propose to create a modular and composable library for variational inference and normalizing flow methods that emphasizes GPU compatibility and seamless integration with the Julia autograd ecosystem. The goal is to develop a user-friendly library that allows researchers and practitioners to easily construct and combine various components for variational approximation of general target distributions, without being tied to specific probabilistic programming frameworks or applications. Turing.jl's Bijectors.jl package offers an outstanding interface for working with normalizing flows; our project will build upon the foundation of Bijectors.jl to further enhance its capabilities and applicability. However, the current design of Bijectors.jl has several limitations such as lack of full GPU compatibility, lack of batch support, etc. Thefore, the main tasks of our projects are to address these limitations for Bijectors.jl, as well as developing the variational inference library.

cjavascriptc+++12
Student: Zuheng (David) Xu
Code

Obstacle Avoidance for Autonomous Driving in CARLA Using Segmentation Deep Learning Models

advanced
JdeRobot•2023Varies350h (Large)

Behavior Metrics is an open-sourced autonomous driving network comparison tool that allows the user to load and test their autonomous driving models in different scenarios and compare the performance metrics against other models. Currently, Behavior Metrics only supports the follow-the-line task, where the vehicle must drive along a circuit while maintaining proximity to the center of the lane, and provides multiple trained models for benchmarking. This project aims to expand the current stack by adding support for a route navigation task where the agent follows a sequence of high-level commands to reach a destination while avoiding obstacles in CARLA simulator, as well as providing an end-to-end learning solution for the task. The ultimate goal is a model that enables an ego vehicle to follow the route while avoiding collision with dynamic objects, such as pedestrians and other vehicles, and comprehensive evaluation metrics for the new task.

pythonrosgazebo+2
Student: Meiqi Zhao
Code

lilypond - Fix Beaming Patterns/Beam Subdivisions and Tuplets

advanced
GNU Project•2023Varies350h (Large)

Many bug reports from almost 10 years ago to even recent times report that GNU Lilypond has been unable to correctly render note subdivision beams and tuple subdivisions, more evidently in some cases of complex rhythm and meter. After comprehensive assessment and analysis of these issues by the developers, the developers have determined that the current code responsible for those capabilities should be rewritten and refactored. The reason that note subdivision and beaming can be difficult to implement is that music theory heavily relies on powers of 2 and their reciprocals. It's very convenient to composers, instrument players and developers too. That convenience doesn't address the problems rhythmic complexity can pose. Concepts such as compound time signatures, tuplets (group of notes that are not bounded by the powers of 2) and manually setting relevant Lilypond attributes. My project proposes a new way of representing the concept of music theory beams and groupings with different object attributes. My project proposes to fix this Lilypond issue by rewriting `lily/beaming-pattern.cc` (the C++ source file mostly responsible for this issue's logic) and fixing/refactoring relevant C++/Scheme source files. I plan to first refactor such source files to fix regular note automatic subdivision and beaming, then fix tuplet subdivision in later weeks. Heavy code modifications will include updating documentation, adding regression tests, and formatting Lilypond's `convert-ly` rules corresponding to the above two issues. Once the issue of beaming subdivisions is fixed, developers and even anyone wishing to compose rhythmically-complex scores should not have to worry about this obstacle.

cpythonposix+12
Student: Jason Yip
Code
Proposal

AI Code Completion for Apache Beam Java SDK.

intermediate
Apache Software Foundation•2023Varies175h (Medium)

Currently, Beam has code completion plugins for Python and Golang SDKs in JetBrains IDEs. For example, Pycharm has a plugin called Alabaster that suggests beam transforms after typing a pipe character. However, IntelliJ IDEA does not have code completion for the Beam Java SDK. In this project, I will implement an IntelliJ Plugin to auto-complete beam transforms for Java SDK users using a Starcoder Language Model.

pythonjavascriptjava+7
Student: Saadat
Code
Proposal

PyBaMM Techno-Economic Analysis Library

advanced
NumFOCUS•2023Varies350h (Large)

A very interesting and nice thing during the development of batteries are back-of-the-envelope estimations. An example might be to estimate an areal loading of active material necessary to compete with another active material, which has different capacity and potential. The different loading would also influence the entire cell and process design such that a coupled cell-process-cost model could give much more accurate and holistic cost estimates than single rules of thumb can. The coupling of cell and process can be achieved by decomposing the process into decoupled process units, which are then connected with cell parameters, e.g. areal loadings. The flexible submodel structure of PyBaMM would enable the use of independent “plug and play” economics e.g. for modeling different processes and economies of scale, as well as the combination of other PyBaMM models to estimate key values for degradation and thermal performance. Making it possible e.g. to study the interplay between formation and degradation accompanied with costs and other key values such as energy densities.

pythonjavascriptr+3
Student: Julian Evers
Code
Proposal

ROOT - TMVA SOFIE Developments - Inference Code Generation for Deep Learning models

beginner
CERN-HSF•2023Varies90h (Small)

Toolkit for Multivariate Analysis (TMVA) is a multi-purpose machine learning toolkit integrated into the ROOT scientific software framework, used in many particle physics data analysis and applications. Currently, we are developing a fast inference system in TMVA, called SOFIE, that takes takes ONNX model as input and produces compilation-ready standalone C++ scripts as output. These scripts will then provide users an easy way to deploy their deep learning models in their physics software and analysis frameworks. This project will focus on development of some missing deep learning operations which will allow to build more complex networks within TMVA for parsing the Transformer based models and Graph Net Models in SOFIE. Specifically, we propose to implement the inference functionality of some ONNX operators in the code generation format. The student can choose to build this based on existing implementations in TMVA or other existing machine learning software tools or build their own from scratch. The expected result is a working implementation of modular operators classes that implement the operators as defined by the ONNX standards in the code generation format. The project requires also to write the corresponding unit tests need to validate the written code.

pythonc/c++machine learning+6
Student: Neel Shah
Code

Convert CellBox Tensorflow code to Pytorch

intermediate
National Resource for Network Biology (NRNB)•2023Varies175h (Medium)

CellBox is a model for predicting cell states under drug perturbations, whose code base was originally written in Tensorflow 1. Since Tensorflow 1 has been replaced by Tensorflow 2 and Pytorch, the aim of the project is to recreate CellBox in Pytorch. There are three main components of the model: the data processing pipeline, the model architecture, and the training process, all of which will be sequentially converted into Pytorch. After the conversion is complete, the new Pytorch model is trained using the same training configurations as the Tensorflow model. The following deliverables define the proposal’s success: the trained Pytorch model should reproduce the same results as the current Tensorflow model; the new Pytorch code base should be configured to be able to run on multiple platforms (Linux, Mac, …); and the github should have clear documentations for installing and running the model.

pythonjavascriptjava+11
Student: Phuc Nguyen
Code

Embedded Chat 2023

intermediate
rocket.chat•2023Varies175h (Medium)

A Rocket.Chat channel could be embedded into some existing web applications via the Embedded Chat component. Currently, the available integration surface and features of Embedded Chat are rather limited. This project aims to significantly expand the applicability of Embedded Chat to a wider range of web/mobile applications built on the most popular frameworks such as React, React Native, and more; and hosting platforms such as WordPress and Ghost via HTML embedding. The goals of the project are: ● Separating various parts of the project into their package - API, react, react native, auth, etc. ● Reducing the bundle size. Currently, it is very large. ● Replacing HTTP calls with real-time DDP communication wherever necessary. ● Creating libraries for react-native, react, etc. ● Giving more flexibility in authentication methods. ● Slash command support ● Introducing theming for client libraries ● HTML embed

javascriptwebrtcmeteor.js+18
Student: abhinavkrin
Code
Proposal

Arduino Flavor

intermediate
International Catrobat Association•2023Varies175h (Medium)

In the current version of the Android app Pocket Code, it is only possible to control some basic functions of an Arduino. Therefore, this project aims to create a new Arduino flavor with many more functionalities for controlling an Arduino. This opens many possibilities in the context of the Internet of Things (IoT) and allows the quick realization of own projects.

javascriptandroidswift+4
Student: David Andrawes
Code
Proposal

capa: Capabilities from Dynamic Analysis

intermediate
FLARE•2023Varies175h (Medium)

capa is an open-source tool that identifies program capabilities using an extensible rule set. Currently, the project relies purely on static analysis of code structures to identify patterns. This project extends capa to work on dynamic execution data such as sandbox run traces or code emulation analysis. The introduction of dynamic analysis to capa is set to make analyzing samples that feature anti-analysis techniques a much easier task. This is an issue of concern since a large number of distributed software nowadays gets packed with commercial or private packers, which means that capa would fail to profile these executables' capabilities successfully. However, this can be circumvented by introducing dynamic analysis to the problem, which it would enable capa to get a view of the program after it had been unpacked in memory, thereby making it possible to extract the capabilities from the executable at hand. Deliverables: 1. Add support for the future integration of several sandbox solutions by means of an associated feature extractor. 2. Implement a feature extractor for the Cuckoo-based CAPE Malware Configuration and Payload Extractor. 3. Introduce capa features that are specific to dynamic analysis (such as captured network traffic). 4. Add dynamic-based support for function call arguments. 5. Write novel rules that make use of the newly introduced dynamic capability extraction.

pythonida-proGhidra+1
Student: yelhamer
Code
Proposal

Identifying the Physical Process of Planet Formation (EXXA)

advanced
Machine Learning for Science (ML4SCI)•2023Varies350h (Large)

Planets form in complex, dynamic environments. The physics behind the process is not well-understood, and the limited high-quality observational data is difficult to interpret. Using high-fidelity hydrodynamical simulations of protoplanetary disk evolution under a variety of physical and observational conditions, machine learning models will be trained that can identify and quantify the physical processes that influence the protoplanetary disk. This will speed up and improve the analysis of observations, furthering our understanding of the environments and processes that are responsible for planets.

pythonmachine learningc+++2
Student: Jason Terry
Code
Proposal

Implement hpx::relocate (P1144)

beginner
Ste||ar group•2023Varies90h (Small)

Modern C++ specifications and the HPX library offer a rich set of algorithms to ensure efficient resource utilization. Nevertheless, there is still room for improvement in data movement operations. Proposal P1144 introduces std::relocate, a feature designed to optimize data relocation by making it safer, faster, and greatly simpler. Essentially, std::relocate utilizes a single memcpy operation to move objects while avoiding unnecessary move-constructor and destructor calls. This improvement impacts key primitives like swap and vector.reserve, subsequently leading to speedup in higher-level algorithms such as rotate and sort. The goal of this proposal is to implement relocation in HPX.

c++cudaopencl+10
Student: Isidoros
Code
Proposal

Extending GraphNeuralNetworks.jl to support Temporal Graphs

intermediate
The Julia Language•2023Varies175h (Medium)

The purpose of this project is to add Temporal Graph Neural Networks (TGNNs) to GraphNeuralNetworks.jl. The first part of the project will be dedicated to creating a temporal graph type and providing it with all the accessory functions. After that, new layers will be added to the package to build models that fall under the category of STGNNs. Thus, new datasets of temporal graphs will be included in MLDatasets.jl to be used for training the models. Finally, tutorials will be produced to complete the project, introducing the new temporal graph type and showing how to perform temporal graph tasks using the added data, model and features.

cjavascriptc+++12
Student: Aurora Rossi
Code
Proposal

Feed Section in Android App

intermediate
MetaBrainz Foundation Inc•2023Varies175h (Medium)

ListenBrainz's website is an amazing platform that inculcates the idea of having a social media app revolving around music. The Feed-Section is one of the core functionalities of this idea, and the ListenBrainz Android app lacks it. Using TDD (test-driven development), Material3, and modern Jetpack libraries in conjunction with the MVVM architecture, this project aims to integrate Feed-Section into the Android app.

pythonjavascriptperl+8
Student: Jasjeet Singh
Code
Proposal

Common API for large molecular databases

intermediate
OpenAstronomy•2023Varies175h (Medium)

RADIS can handle different databases such as HITRAN, HITEMP, EXOMOL, GEISA, etc. Another open-source code, called EXOJAX, exchanged portions of code with RADIS until some parts of both codes became very similar. Currently, a database API is written in the RADIS code. The main goal of the current project is to improve this common API to download and manage databases. The mentee will not start from scratch because the community already worked on the problem and set up a frame for this big merge of code built around a DatabaseManager class.

cpythonjulia+7
Student: menasrac
Code
Proposal

NodeCloud

beginner
SCoRe Lab•2023Varies90h (Small)

NodeCloud is a standard library to get a single API on the open cloud with multiple providers. It is a NodeJs library which comes with plugins for each cloud provider. NodeCloud's aim is to abstract away the differences between different cloud providers. It provides an easy to use API for developers in order to interact with different cloud providers.

pythonmachine learningweb development+8
Student: Partik Singh
Code
Proposal

Refactor Metrics Interface/Implementation in Mantis

advanced
Mantis•2023Varies350h (Large)

Improve the Mantis metrics system by replacing the existing implementation with a more standardized and flexible OSS library which should be easier to support other time-series databases, reduce complexity, and improve scalability.

javaRxjavaAkka+1
Student: Jue Wu
Code
Proposal
Showing 3913 - 3936 of 13453 Projects
162163164165166
Proposal
Proposal
Proposal
Proposal
Proposal