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

AudioWorklets IDE

advanced
Chromium•2024Varies

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)

The AudioWorkletNode is the one of the most widely-used and functional nodes in the Web Audio API. Given its unique ability to allow developers to run code in a worker thread, AudioWorklets allow for real-time high-performance sound processing that also does not block the main thread’s execution in potentially computationally-expensive tasks. I propose creating a specialized IDE tailored for AudioWorklet development. Inspired by existing web-based IDEs like FaustIDE and WebChucK, it aims to streamline the process of creating processors. The proposed IDE would offer features such as importing code from AudioWorklet examples, providing GUI elements for visualization, and integrating tools for testing code, including precise test cases and a graphical editor for audio graphing. The goal is to enhance user experience and facilitate the creation and testing of AudioWorklet implementations.

pythonjavascriptjava+2
Student: Tristan
Code
Proposal

Text Recognition with Transformer Models

advanced
HumanAI•2024Varies350h (Large)

Optical Character Recognition (OCR) technology has revolutionised document digitization, converting printed and handwritten text into machine-readable formats. However, recognizing text from centuries-old works remains challenging due to the complexity of early non-standard print forms, handwritten texts, and manuscripts. Existing OCR tools like Adobe Acrobat and Google’s Pytesseract OCR often struggle with historical documents due to variations in font styles, image quality, degradation, and layouts. This project aims to develop a hybrid end-to-end Transformer model capable of accurately recognizing text from non-standard Spanish printed sources from the 16th and 17th centuries.

pythonmachine learningc+++2
Student: Arsh Ahmed Faisal Khan
Code
Proposal

Enhancement of RL Approach Accessibility in NR

intermediate
The ns-3 Network Simulator Project•2024Varies175h (Medium)

In wireless networking, research utilizing reinforcement learning is on the rise. In response, ns-3 has introduced additional modules like ns3-gym and ns3-ai to support such research. With the increasing traffic and diverse services, 5G NR has been developed and is supported in ns-3 via 5G-LENA. However, there's a need for more reinforcement learning examples based on NR. Additionally, improving the ease of use of multi-agent reinforcement learning (MARL) approaches aims to enhance the usability of NR Sidelink, enabling distributed operations. In this project, I will improve the interface between OpenGymEnv in ns3 and ns3env in the Python ns3 gym module for Multi-Agent Reinforcement Learning (MARL). Currently, ns3gym utilizes the REQ-REP pattern in ZeroMQ as the interface. By incorporating techniques such as client identity and parallel processing of workers in ZMQ, I aim to develop a MARL interface in ns3gym. Additionally, I will enhance the usability of 5G by implementing MARL approaches in 5G examples, with a specific focus on 5G LENA.

pythonc++c/c+++2
Student: mye280c37
Code
Proposal

TensorMap

advanced
C2SI•2024Varies350h (Large)

This year's goal aims to enhance the TensorMap web application by addressing technical challenges and introducing functionalities to improve usability and efficiency. Key issues, such as dependency management and server-side complexity, will be tackled by Dockerizing the backend for easier deployment. Fixing the neural architecture design workflow will also be the main focus of this year's contribution. New features planned to be introduced into the project include support for image datasets with Convolutional Neural Networks (CNNs), addition of linear regression models for regression tasks, and dataset preprocessing for a better user experience. Finally, documentation on introducing new nodes for future contributors and users along with improved testing coverage for client-side reliability will also be implemented.

pythonjavago+2
Student: Saatwik Vasishtha
Code
Proposal

TinyParrot: A minimal BlackParrot RISC-V Multicore variant

advanced
Free and Open Source Silicon Foundation•2024Varies350h (Large)

TinyParrot is a BlackParrot RISC-V multi-core variant that aims to be small enough to fit onto educational FPGA development boards like the Pynq Z2. In order to get there, the TinyParrot variant needs to optimize and constrain itself in order to meet the physical device constraints (such as LUTs, BRAMs, and flip-flops) provided by development boards like the Pynq Z2 FPGA development board. This project will implement size optimizations that ultimately decrease the amount of resources required by TinyParrot, enabling TinyParrot to fit on the Pynq Z2. At a high level, this will be accomplished by first parameterizing the FMUL/FDIV instructions as part of an MFD parameterization effort. Then, hardware primitives will be re-mapping using the BaseJump STL library in order to standardize and optimize the existing RTL. The ultimate goal of these optimization efforts is to implement TinyParrot on the Pynq Z2.

pythonjavascriptfpga+11
Student: Colin Knizek
Code

Generating Pd patches using an LLM

intermediate
Purr Data•2024Varies175h (Medium)

Purr-Data (Pd), a visual programming language for multimedia applications, offers a powerful and intuitive environment for sound and music creation. However, the initial learning curve for Pd can be daunting, especially for those unfamiliar with visual programming paradigms. Also, the experienced Purr-data users would want to generate patches faster. This project titled "Generating Pd Patches Using an LLM", aims to bridge this gap by leveraging the power of machine learning to assist users in creating Pd patches.

javascriptc/c++node.js+9
Student: Amrut Kotrannavar
Code
Proposal

Learning quantum representations of classical high energy physics data with contrastive learning

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

This project investigates the fusion of classical data encoding onto quantum models using contrastive learning techniques. The objective is to develop a function for encoding classical data onto quantum feature spaces, enabling their representation in a format compatible with quantum processing. By contrasting positive (similar) and negative (dissimilar) pairs in the feature space, contrastive learning facilitates representation learning. The trained embeddings will be assessed against standard encoding approaches using quantum machine learning (QML) models, providing insights into their performance. Through this exploration, the aim is to evaluate the efficacy of quantum embeddings for classical data and compare them with traditional encoding techniques. By harnessing the capabilities of quantum computing and contrastive learning, this endeavor contributes to advancing classical data encoding on quantum platforms, potentially unlocking novel applications in quantum-enhanced machine learning.

pythonmachine learningc+++2
Student: Sanya Nanda
Code

Porting and Optimizing OpenVINO for RISC-V Devices with Vector Extension

advanced
OpenVINO Toolkit•2024Varies350h (Large)

[Problem] The project aims to enhance the runtime performance of OpenVINO on RISC-V devices to fully leverage their power efficiency for running DL/AI workloads efficiently. [Methodology] This will be achieved through three key optimization strategies: adopting or improving third-party libraries with RISC-V optimized primitives, porting existing x86/ARM optimized kernels to RISC-V ISA, and implementing device-specific transformation passes tailored for RISC-V backend optimizations. [Deliverables] The project will deliver: 1. Adoption of optimized RISC-V kernels from third-party libraries for more operations in OpenVINO. 2. Porting of critical x86/ARM optimizations to RISC-V ISA. 3. Implementation of device-specific transformation passes for RISC-V backend requirements. 4. Demonstrated improvement in OpenVINO runtime performance on RISC-V CPU devices through benchmarking against determined workloads.

pythonc++x86+1
Student: BHbean
Code

Setting up a framework for large-scale development

intermediate
Open Science Initiative for Perfusion Imaging•2024Varies175h (Medium)

Project Overview: The OSIPI framework project aims to establish a robust structure for large-scale development, focusing on best practices for codebase management with multiple contributors. This initiative will enhance collaborative development and streamline the integration of various developers’ contributions. Solution Strategy: To address the project’s needs, the following strategy will be implemented: Develop and implement essential framework functionalities based on project requirements. Engage in continuous testing and refinement of the code throughout the development process. Regularly update the documentation to reflect the evolution of functionalities. Work towards extending the capabilities of the OSIPI framework as the project progresses.

pythongithub
Student: Mohamed Nasser Hussein
Code
Proposal

AsynAPI: Conference Website Maintainence

intermediate
AsyncAPI•2024Varies175h (Medium)

The project lies under Postman and AsyncAPI, which is an open-source organisation that is developing an ecosystem around Event Driven Architecture of API's. Essentially transforming the way we interact with API's and giving a new look to the standard REST API that is the industry standard. To support this they have various project under their belt. To promote these and spread awareness about them and the dev's to interact with each other. AsyncAPI plans on the AsyncAPI Conf on Tour 2024, which will utilise this project.

javascriptjavago+2
Student: Ashmit Jagtap
Code
Proposal

Developing a binary pair format

intermediate
Open Chromosome Collective•2024Varies175h (Medium)

Problem: Storing Hi-C contacts in a gzipped .tsv format, which is mainly used in pairtools, cause major slowdowns for computations and storing. Solution: develop a new binary pairs format, based on Apache Parquet to speed up storing and significantly reduce memory storage. Why this particular solution?: Incorporating Apache Parquet into the pairtools framework will streamline data storage and retrieval processes, significantly reducing disk space requirements and improving data access speeds. Integration with Hi-C data processing pipelines will enhance scalability and efficiency, enabling seamless handling of large-scale genomic datasets while maintaining compatibility with existing pairtools functionalities. Deliverables: 1. Develop and implement Apache Parquet pairs format within pairtools for efficient storage and retrieval of genomic interaction data. 2. Integrate Hi-C data processing functionalities related to new created format into pairtools to enable seamless analysis of large-scale genomic datasets.

pythonnumpyscikit-learn+2
Student: Olesia Slavska
Code
Proposal

Implementation of the procps tools in Rust

intermediate
Debian•2024Varies175h (Medium)

The current uutils project is progressing well, and coreutils in particular is even partially production-ready. However, there are still not enough implementations of procps, so this proposal will focus on improving the availability of procps.

pythonjavascriptc/c+++8
Student: Krysztal Huang
Code
Proposal

P4 Formatter

intermediate
The P4 Language Consortium•2024Varies175h (Medium)

P4 (Programming Protocol-independent Packet Processors) is a domain-specific language for network devices. It allows programmers to specify how data plane elements (switches, NICs, routers) process packets without needing to deal with the specifics of the underlying hardware. The absence of a code formatter for the P4lang poses challenges for developers working on large codebases, hindering efforts to maintain consistent coding styles across projects.This project aims to address this gap by developing a code formatter specifically tailored for P4. This would enhance productivity by standardising coding styles, facilitating collaboration among developers, and improving code readability. By implementing this tool, developers will be able to efficiently format P4 codebases, ensuring adherence to coding standards and fostering a more streamlined development process.

llvmc++mlir+3
Student: Nitish Kumar.
Code
Proposal

Develop further the new GUI for BRL-CAD!

intermediate
BRL-CAD•2024Varies175h (Medium)

The proposal aims to enhance the BRL-CAD experience through a new GUI. Leveraging my software development background, including projects like Website Buddy and an Inventory Management System, I'll tackle Arbalest's limitations. Familiar with BRL-CAD components and ongoing codebase exploration, I'll fix bugs, add navigation, resize primitives, create a toolbar, and extend the C++ Geometry API. Four milestones with specific deliverables and a development timeline will ensure progress. With a commitment of 21 hours per week and flexibility for academic commitments, I'm dedicated to the project's success. My passion for open-source development and positive experiences within the BRL-CAD community drive my involvement. With proficiency in C++ and Qt, I'm prepared to contribute effectively to enhance the BRL-CAD user experience.

pythonc/c++opengl+6
Student: ViditJain04
Code
Proposal

A Node Based Filter Editor for Inkscape

beginner
Inkscape•2024Varies90h (Small)

Inkscape's current Filter Editor limits the user experience for creating Filters significantly, due to it's non-intuitive nature, and poor structing. Filters can be a great tool in any artist's inventory, due to the endless scope of effects they are capable of creating. However, the current Editor does a poor job at inviting artists to utilise the complete power of Filters. To solve this problem, I plan on replacing the current Filter Editor with A Node-Based one, since such a Node based workflow seems like the most natural one, for working with filters. The proposed Node - based Filter Editor promises to have the following deliverables: 1. An intuitive, easy to pick up, node based filter editor, with intuitive, user-friendly controls with a full-fledged editing workflow containing: a) essential features for navigation and canvas operations such as scrolling, zooming, panning, etc., relevant contextual menus, etc. b) Intuitive node operations such as selections, an easy system to make connections between nodes with clean and well planned user interfaces. c) Support for all Filters and Filter Primitives, along with widgets aimed at being easy to understand, which allow editing the properties of the Filter Primitives d) Ability to save and load the state of the editor, when closing and re-opening, or automatically creating a suitable layout for arranging the nodes, in a clean manner. 2. Creating template classes which can be used in future to implement functionalities requiring similar workflows. 3. Documentation and video series to further help users understand the editor and learn about it's various features, along with providing insight into the power of Filters.

pythonc++css+6
Student: Ravi Arora
Code
Proposal

Mission Support System: Improve multiple flightpath docking widget

intermediate
Python Software Foundation•2024Varies175h (Medium)

The Multiple Flightpath Docking Widget in MSS is crucial for visualizing atmospheric data but lacks customization options hindering effective comparison of flight paths. This project aims to enhance the widget's functionality by introducing centralized line controls, adjustable transparency, Matplotlib linestyle options, automatic color assignment, regex filtering, select all/deselect all buttons, integrated legend, operation labeling, and saving user preferences using QSettings. (Deliverables): Enhanced UI with centralized controls. Improved backend filtering with regex. Comprehensive legend design with synchronization. Annotation feature for operation labeling. QSettings implementation for saving/loading preferences. Test cases, documentation, and future work suggestions.

pythonmercurialjavascript+3
Student: Rohit Prasad
Code

Adding NSGA-3 and AGE-MOEA Multi Objective Optimizers

advanced
mlpack•2024Varies350h (Large)

Multi-objective optimization (MOO) plays a crucial role in decision-making across diverse fields, where conflicting objectives need to be balanced. This project proposes to enhance ensmallen's capabilities in MOO by implementing NSGA-III (Non-dominated Sorting Genetic Algorithm III) and AGE-MOEA (Adaptive Geometry Estimation-based Multi-Objective Evolutionary Algorithm). Furthermore, the project aims to add the Maf benchmark problems suite, which are based on real-world problems with varying properties, to benchmark the currently implemented optimizers based on both time taken and IGD score.

c++pythonmachine learning+4
Student: Satyam Govind Shukla
Code
Proposal

New serverless benchmarks

advanced
Scalable Parallel Computing Laboratory•2024Varies350h (Large)

The serverless computing landscape is constantly evolving with new types of applications and use-cases. To ensure the SeBS benchmarking suite remains relevant and comprehensive, this project aims to extend it by introducing new function candidates, invocation types, and serverless workflows. The project's objective is to develop and integrate new benchmarks that can be executed successfully on already supported serverless platforms.

pythonc++mpi+2
Student: AbhishekKumar
Code
Proposal

Implementing a React UI Console for Test Generation demonstration

intermediate
Keploy•2024Varies175h (Medium)

Writing unit test cases can be challenging and sometimes not an efficient process. Keploy creates backend API tests with built-in-mocks or stubs by recording your application network calls making your testing process not only faster than unit tests but also incredibly efficient.This project aims to develop a console with keploy which will allow user to have hands on experience with keploy.Capturing the test-cases , replaying the captured test-cases and testing with your favourite library is allowed in the console using keploy. Also Interactive guide will be provided to the user distributed in different parts so that the user can follow through the process easily. Additionaly there will be web-stories so that the user get acquainted with the latest news about Keploy.

javagolangnode+4
Student: Aditya-eddy
Code
Proposal

perf trace and BTF

intermediate
The Linux Foundation•2024Varies175h (Medium)

Background: perf trace is similar to strace but much performant since it doesn't use ptrace. So it needs to capture and understand the format of syscall arguments as strace does. Right now, it has to build a list of format to pretty-print the syscall args. But we find it limited and manual work. Instead, it could use BTF (BPF type format) which has all the type information and is available in the (most) kernel. Deliverables: 1. A new method of fetching augmented argument data. 2. Implementation of an auto-generated beauty map that stores the type and size of augmented syscall argument, based on BTF. 3. eBPF side augmented argument caching refactoring. 4. Pretty print feature to visualize data from struct pointer, char* string, etc, using BTF. 5. New sets of command line arguments to control pretty printing.

cpythonmysql+7
Student: Howard Chu
Code
Proposal

Crypt4GH Support for GA4GH Task Execution Service API Implementations

beginner
Global Alliance for Genomics and Health•2024Varies90h (Small)

Crypt4GH is a file format developed by GA4GH that keeps genomic data encrypted at rest and in transit. Currently, implementations of the TES API do not support processing Crypt4GH files. I propose an implementation of the TES API that handles Crypt4GH files through the use of middleware that alters the initial TES request in order decrypt Crypt4GH files before processing. First, I will create a "TES playground" that is able to run a simple task. Then, I will add to the functionality of this playground in order to demonstrate an implementation of the TES API that can handle a Crypt4GH-encrypted file as an input. This project will hopefully serve as a proof-of-concept to inform future standard-setting works.

pythonjavamongodb+10
Student: Athitheya Gobinathan
Code

Building an API Client for OBA Servers

intermediate
Open Transit Software Foundation•2024Varies175h (Medium)

Summary: The OBA project aims to develop official OneBusAway REST API client libraries in TypeScript and Python, enhancing accessibility and user experience for developers interacting with OneBusAway servers. These libraries will support all REST API methods, handle diverse data types, include comprehensive tests, and provide helpful examples for new users. About Me: I am Ahmed Hossam, a senior information technology student with a passion for technology and problem-solving. With experience in backend engineering and competitive programming, I am excited to contribute to the OBA project and make a positive impact. Investigations: I have familiarized myself with OneBusAway endpoints, built a beta version of the TypeScript package, and experimented with different structures for scalability and maintainability. Detailed Design: The API client follows a modular structure, with each endpoint encapsulated within its own module. It employs a combination of factory and dependency injection patterns and includes a base class for foundational HTTP request functionality. Implementation Plan: I will collaborate closely with mentors to understand API client requirements and plan implementation details. Error handling and unit testing will be prioritized, followed by thorough testing and the publishing of final packages. Proposal Timeline: The timeline spans 14 weeks, beginning with communication and research in the first three weeks, followed by official coding in TypeScript. Python implementation will commence in week 9, with completion and finalization in week 14. Why Me: I find joy in making OBA APIs accessible to everyone and am dedicated to contributing positively to the project. My experience in API development, along with continuous learning, makes me well-suited for this role.

androidjavagolang+2
Student: Ahmed Hossam
Code
Proposal

Maths-Tutor QT Version and Enhancement

intermediate
Zendalona•2024Varies175h (Medium)

I propose to update the Math-Tutor App by leveraging Qt to design a more modern and elegant interface which would result in a heightened user experience and greater adoption over time. Specifically, I plan to implement multiple features into the Math Tutor App which has been requested by Zendalona. This includes the addition of options to widen the subjects that are currently supported, a more personalized software which stores and reflects the scores and progress of each user and an app that’s more accessible to the end-user.

pythonjavascriptandroid+2
Student: Ronak kumbhat
Code
Proposal

Improved debugging support for Pallene

advanced
LabLua•2024Varies350h (Large)

Pallene is a statically typed companion language to Lua, designed to write performance sensitive part of it. Pallene has a very similar syntax as Lua, sharing its runtime as well. Pallene is Ahead-of-Time compiled language, compiling into C before getting compiled into a Lua module. As the situation stands for Lua stack trace, it does not store any line number information for any native C call, which Pallene eventually ends up using. There are also missing traces when a Pallene function calls another Pallene function as the call is in Pallene environment and completely oblivious to Lua. This proposal aims to fix that issue in Pallene, improving its overall debugging support.

luacéuelasticsearch+5
Student: SD Asif Hossein
Code
Proposal
Showing 3241 - 3264 of 11996 Projects
134135136137138
Proposal
Proposal
Proposal
Proposal
Proposal