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 Clear
11996 Projects Found
Sort by

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

beginner
CERN-HSF•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 →
90h (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
Proposal

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

Develop new features for Cytoscape App-cyPlot

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

This project involves updating cyPlot(a Cytoscape app written in JAVA) which provides the ability to plot data through GUI or CyCommands/REST. CyPlot uses plotly.js to achieve plot related functions. CyPlot also customizes plotly.js and PlotlyEditor to suit the needs of CyPlot. It currently supports plots including heatmaps, violin plots, volcano plots, dot plots, line graphs, and scatter plots. The main goals of this project include: 1. Add Histogram as an additional plot type. 2. Implement log scales for scatter plot, line plot and histogram plot. 3. Support linear regression. 4. Updated user interface (UI)

pythonjavascriptjava+11
Student: Kartik Kumar Pawar
Code
Proposal

GitHub Actions - Optimizing CI Pipeline and Utilizing the Whole Docker Stack for Testing

intermediate
PEcAn Project•2023Varies175h (Medium)

Worked on optimising the CI pipeline, After reconfiguration and optimisation of the pipeline, I was successfully able to reduce the time taken for building by more than 70%. Created several Github Actions to automate nearly 60% of the tasks which were previously done manually and optimised the unnecessary use of resources to a large extent Successfully brought up the whole system against the full docker stack Fixed the API’s to connect in all environments on any runner machine

cpostgresqljavascript+8
Student: Rohan Sasne
Code
Proposal

Scaling Formal Verification: Parallel Analysis of Functions

advanced
Software and Computational Systems Lab at LMU Munich•2023Varies350h (Large)

Formal methods have been known to be useful for verifying critical software. However, one of the main factors keeping tools such as CPA-Checker from being more widely adopted in industry is the prohibitive amount of time it takes to verify complex programs. We wish to address this by making CPAChecker scalable via divide-and-conquer and parallelization. We want to come up with a mechanical approach for decomposing verification tasks into subtasks that can verified individually. As soon as one subtask finds a violation, we abort the rest and return the violation.

pythonjavascriptjava+2
Student: George Granberry
Code
Proposal

The LiquidArt AI

intermediate
Liquid Galaxy project•2023Varies175h (Medium)

The LiquidArt AI is a mobile application developed in Flutter that allows users to generate images using a text or an audio to text prompt and a selection of APIs (NightCafe, a local server of Stable Diffusion, AI Art Maker, Dall-e), a multi-screen system for displaying geographic information. The application uses a Node js server to connect to the Liquid Galaxy system and a custom API to display the images on the screens. The project also includes a new local machine for the LG project that has a GPU and the ability to create AI art based on stable diffusion.

javascriptrosgis+14
Student: Murilo Nogueira Duarte
Code
Proposal

Adaptive MIRK BVP solvers

intermediate
NumFOCUS•2023Varies175h (Medium)

Boundary value problems (BVPs) are mathematical models that arise in a variety of fields, such as economics and chemistry. BVPs are essentially ordinary differential equations (ODEs), but with additional constraints. The current implementation of MIRK solvers in BoundaryValueDiffEq.jl does not support defect control and mesh uniform refinement, which really hindered its application. To address this limitation, the goal of this project is to implement defect control for MIRK (Monotonic Implicit Runge-Kutta) solvers and to add mesh uniform refinement to BoundaryValueDiffEq.jl, thus enhancing the capabilities of SciML's differential equations solvers in solving BVPs。

pythonjavascriptr+3
Student: Qingyu Qu
Code
Proposal

REST API Completion and improvement

intermediate
FOSSology•2023Varies175h (Medium)

Developing the remaining REST APIs that are required to expose the database for the new FossologyUI. This proposal also focuses on implementing test cases for the existing and upcoming APIs for the Fossology server.

linuxpostgresqlc/c+++7
Student: Soham Banerjee
Code
Proposal

Robotics Academy: Migration to ROS2 Humble

intermediate
JdeRobot•2023Varies175h (Medium)

The Robotics Academy is a framework designed for learning robotics and computer vision through a collection of robot programming exercises. Currently, the platform offers 26 exercises and 11 prototype exercises that students can access through the RoboticsAcademy docker image (RADI), which comes pre-installed with all necessary dependencies. The RADI is a key component of the platform, and this project aims to improve it by migrating it to ROS2 Humble Hawksbill from the current ROS noetic version, which is nearing its end of life (2025). The project will involve implementing a few exercises in ROS2 with the new RADI as well as the addition of ROS2 tools such as RViz2 to exercises. Additionally, the project may explore topics such as size optimization, multi-rosdistro docker images, and hardware acceleration.

pythonrosgazebo+2
Student: Pawan Wadhwani
Code
Proposal

Implement calendar availability

intermediate
KDE Community•2023Varies175h (Medium)

This feature implements RFC 7953 in the Kalendar app. This adds the ability for a user to provide their availability in a shared calendar. When a user wants to schedule a meeting, with this feature in place, they will be suggested better intervals by taking the availability of the attendees into consideration. This updates KCalendarCore and the Kalendar projects (for the most part) of the KDE ecosystem.

c/c++qtqml+6
Student: InfiniteVerma
Code
Proposal

Showcase performance of PyTorch Image Models (Timm) with OpenVINO

advanced
OpenVINO Toolkit•2023Varies350h (Large)

My proposal aims to optimize PyTorch Image Models (Timm) using OpenVINO and NNCF libraries. The problem at hand is that these models are computationally intensive and require a lot of resources, making them challenging to deploy in resource-limited environments. To solve this problem, I plan to implement optimization techniques such as quantization, pruning, and compression on a selected subset of models from the Timm library. I will evaluate the performance of these optimized models on different hardware platforms and compare them with the baseline models. The deliverables for this project include optimized Timm models, a tutorial notebook detailing the setup and usage of OpenVINO and NNCF libraries, and documentation and tests for the code developed during the project. If my proposal is accepted, I am excited to work on this project and contribute to the community by making these models more accessible and efficient to deploy.

pythonc++x86+1
Student: Sawradip Saha
Code
Proposal

Music Blocks v4 Project Builder Integration

advanced
Sugar Labs•2023Varies350h (Large)

The Music Blocks v4 project is a complete overhaul of the original Music Blocks project, which was derived from the Turtle Blocks project. The existing implementation, which started in 2015 using native Vanilla JavaScript, lacks modern front-end tooling and ecosystem standards, leading to difficulties in maintenance and subpar performance. The v4 project uses improved application architecture, modern tools (such as Vite, ESLint, Prettier, Docker, Jest, Cypress, etc.), better languages (TypeScript and Sass), and libraries (React for UI rendering). This will significantly enhance the overall developer and user experience, maintainability, and performance. The proposal focuses on implementing one of the main features of Music Blocks, the "Project Builder", which is currently missing in the new version (v4). The Project Builder is a graphical blocks manager module used to create Music Blocks programs, including interactive blocks like Start, Rhythm, Note, Pitch, Instrument, and many more. These blocks can be dragged, dropped, and clicked to perform actions or open context menus. By implementing the Project Builder feature end-to-end, users will be able to create different musical patterns seamlessly. This will bring the v4 project on par with the capabilities of the old version (v1) and provide a more accessible, efficient, and user-friendly application for users to create music through an interactive web application.

pythonjavascriptgtk++10
Student: Niloy Sikdar
Code
Proposal

AGL @ Linux Foundation | GSoC 2023 | Enhance Speech Recognition

intermediate
The Linux Foundation•2023$3k–$6.6k175h (Medium)

Abstract: This project aims to enhance the speech recognition engine used in Automotive Grade Linux by creating a natural language intent engine that can understand and respond to commands. The goal is to develop a voice assistant that can understand voice commands and take necessary action based on them (e.g. turn down the volume, increase AC temperature). -- Implementation Details: The current Vosk Kaldi speech-to-text functionality will be enhanced by integrating the Snips and RASA NLU engine. The NLU engine will help in extracting the context and intent of voice commands. The extracted intent will be used directly or indirectly by a gRPC-based service which will execute it by communicating with the underlying Kuksa Server APIs. -- Deliverables: 1.) Integration and development of Snips and RASA Natural Language Understanding Intent Engines with existing Vosk implementation. 2.) Ability to execute the intent extracted from the NLU engine using a gRPC-based server, GStreamer, and Kuksa. 3.) A flutter-based Linux voice assistant app to communicate with the gRPC-based service.

cpythonmysql+7
Student: Malik Talha Saeed
Code

Videoconvert plugin for PipeWire

advanced
X.Org Foundation•2023Varies350h (Large)

Sharing video buffers via PipeWire requires at the moment consumers and producers to provide a common capability set of buffer type, buffer format and in case of hardware buffers drm\_modifier. To mitigate mismatch issues, the goal is creating a PipeWire plugin, similar to the existing audioconvert one, using vulkan as the underlying technology for efficient video format conversions on hardware buffers and optional downloads to system memory. This approach allows producers to focus solely on the most efficient buffer type and format, removing the necessity to provide a fallback to system memory buffers, or its own rendering capabilities, while consumers on the other hand get increased compatibility and don't have to support any possible format. This eases the development of a working PipeWire client, making it possible to implement support for a wider range of formats and more advanced features later.

copenglc+++5
Student: columbarius
Code
Proposal
Showing 3793 - 3816 of 11996 Projects
157158159160161
Proposal
Proposal