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

Lua-Casbin

advanced
Casbin•2021Varies

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)

<p>Nginx is the second most popular web server and the most popular among high-traffic websites. OpenResty is a high performance web platform extended from core Nginx and supports integration of Lua modules. Though still there is a lack of any specialised solution for authorization based on access control models. This real need can be addressed by Casbin perfectly since it supports the 3 major access control models (ACL, RBAC, ABAC). This project aims to implement Casbin’s functionality entirely in Lua and support it as an OpenResty module.</p>

pythonjavascriptgo+7
Student: Rushikesh Tote
Code
Proposal

Uncovering the Enigma of Type-Ia Supernovae: Thermonuclear Supernova Classification via their Nuclear Signatures

intermediate
Machine Learning for Science (ML4SCI) Umbrella Organization•2021Varies175h (Medium)

<p>Fundamental questions about Thermonuclear Supernovae (Type-Ia or SNeIa), the beacons visible across the universe, remain unanswered. Using the currently-available extensive library of detailed supernova simulation data, I aim to identify machine learning and computational techniques suitable for this project, produce a cluster-predict model that identifies cluster classes based on observable parameters, characterize the degree of confidence of the model, and ultimately establish classification metrics for Type-Ia supernovae to prepare for future nuclear astrophysics investigations, advancing our understanding of these beacons of the cosmos.</p>

pythonc/c++machine learning+2
Student: Sophia He
Code

Enhancing bugbug : A platform for Bugzilla machine learning projects

beginner
Mozilla•2019Varies90h (Small)

<p><em>bugbug</em> was started with the aim of making the task of bug tracking simpler, by using machine learning algorithms to differentiate between bugs. However, it is currently in it's early stages. It uses basic feature extractors and a Gradient Boosting Tree classifier to make predictions. With this project, I plan on enhancing the accuracies and capabilities of <em> bugbug</em>, by making the classifiers more robust , implementing deep learning models and additional feature extractors for these models. I hope this project is a solid move towards making the tasks related to bug tracking more convenient.</p>

pythonjavascriptc+++8
Student: Ayush Shridhar
Code
Proposal

Create a Red Hen OpenDataset for gestures with performance baselines

advanced
Red Hen Lab•2021Varies350h (Large)

<p>Red Hen OpenDataset contains annotated gesture videos from talk shows. The project requires to systematize the data for computer science researchers and develop deep learning models as classifiers on the video dataset.</p> <p>The goals of this research project will be as follows:</p> <ol> <li>Organization and systematic characterization of the data into a proper format so that it can be readily used by computer science researchers</li> <li>Developing performance baseline(s) on the dataset</li> <li>Developing a pipeline for testing the models with any video input</li> </ol>

machine learningopencvhigh performance computing+15
Student: Swadesh Jana
Code
Proposal

Contribute to KerasCV and KerasNLP

beginner
TensorFlow•2022Varies90h (Small)

This project aims to add several functionalities to Keras-CV which will be of use to beginner as well as seasoned practitioners. I will be contributing various model blocks, augmentation methods and more to the repository. These implementations will be of great help to create a specialized model catering to the user’s specific needs. I intend to complete the following tasks: 1. Implement Stochastic Depth layer 2. Implement RandomResizedCrop KPL 3. Implement RandomColorAffine KPL 4. Implement Squeeze and Excite layer 5. Implement MBConv and FusedMBConv 6. Implement `get_train_test_split()` in Keras

pythonc/c++machine learning+8
Student: Aditya Kane
Code
Proposal

Automatic Speech Recognition for European Language (German)

intermediate
Red Hen Lab•2019Varies175h (Medium)

<p>This project aims to build an ASR pipeline for European Language (German) and it must be built as a Singularity container on the Case HPC and put into production to process daily incoming files. The project proposes to use different state-of-the-art Speech to Text open source toolkits (Kaldi, DeepSpeech).</p> <p>It can be divided into following sub-tasks:</p> <ol> <li>Data cleaning and Feature Extraction</li> <li>Language Modeling</li> <li>Building Phoneme Dictionary</li> <li>Acoustic Modeling</li> </ol>

machine learningopencvhigh performance computing+15
Student: Aashish Agarwal
Code
Proposal

Debug WebUI For Tabstrip states

advanced
Chromium•2025Varies350h (Large)

This project aims to develop a read-only WebUI page in Chromium, chrome://tab-debug, that provides a live, structured visualization of the tabstrip model, including tab groups, selection state, and session restore metadata. By exposing internal C++ model data via a Mojo interface and rendering it in a Lit-based TypeScript frontend, the tool will help developers debug and inspect complex tab behaviors more easily. The solution will include real-time updates, a collapsible tree view, and raw data toggles, while maintaining strict read-only access for safety.

pythonjavascriptjava+2
Student: Brijesh Giri
Code
Proposal

Quantum Variational Autoencoders for HEP Analysis at the LHC

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

In the search for physics beyond the standard model physics, the growing amount of data and the evasive of the signals that are being searched for, calls for new methods. A prominent method is the use of autoencoders to search for anomalous events in an unsupervised manner. In project I implement a quantum autoencoder to perform anomaly detection on jet images. The goal is to distinguish QCD jets from anomalous jets with a different production mechanism. I train the quantum autoencoder on standard model data and compare it's performance as an anomaly tagger to a classical autoencoder, to study the potential use of quantum machine learning methods to enhance HEP analyses.

pythonmachine learningc+++2
Student: ToMago
Code
Proposal

Reverse Program Synthesis for Backward Reachability Analysis in CPAchecker

intermediate
Software and Computational Systems Lab at LMU Munich•2023Varies175h (Medium)

CPAchecker now supports reachability analysis, which can search for a path from the initial program location to the error location. This project is a Proof of Concept, to implement the Backward Reachability Analysis, i.e. search for a path from the error location to the initial location. The main goal of this project is to implement a control-flow automata (CFA) transformer in CPAchecker that reverses program executions by following the transitions backward, such that for any program path in the original CFA, there is a corresponding equisatisfiable path in reverse CFA. After the transformation, the existing analysis can be applied to verify the reverse CFA, thus enabling the Backward Reachability Analysis.

pythonjavascriptjava+2
Student: Jia Sun
Code

Polly as an Analysis Pass in LLVM

advanced
LLVM Compiler Infrastructure•2016Varies350h (Large)

<p>The Polyhedral framework provides an exact dependence analysis, which is more powerful than conventional dependence testing algorithms. Currently, LLVM mainline lacks a powerful dependence analysis framework, and at the same time, Polly’s (a high level data locality optimizer based on polyhedral framework) dependence analysis is suitable for many transformation passes in LLVM like Loop Vectorization, Loop Versioning, Modulo Scheduling, Loop Nest Optimizations, etc. I want to provide an API to Polly such that its precise dependence analysis can be used as an Analysis pass within LLVM's transformation passes.</p>

cllvmc+++3
Student: Utpal
Code
Proposal

Kubernetes ontology and subgraph module design

Intermediate
•Varies175h (Medium)

Network topologies and graph databases go hand-in-hand. The OpenAPI specifications for Kubernetes provides taxonomy, but augmenting a graph data model with formalized ontologies enables any number of capabilities, one of the more straightforward is the inferencing requisite for natural language processing, and consequently, a human-centric query / response interaction becomes becomes possible. More importantly, more advanced systems can be built when a graph data model of connected systems is upgraded to be a knowledge semantic graph. Deliverables (among other items): - a Kubernetes ontology using OWL as a popular (and mature) way of doing this. - a cuelang-based component generator

TBA
Proposal

LLM Hyperparameters Tuning API Proposal (Project 4)

advanced
Kubeflow•2024Varies350h (Large)

This proposal aims to address the challenge of tuning hyperparameters for Large Language Models (LLMs) by developing a user-friendly high-level API. Leveraging the method used in the Training Operator for importing pre-trained models and datasets from external platforms, we will create a tune function similar to existing methods. This will empower users to easily explore various hyperparameter configurations through the API, optimizing LLM performance without requiring in-depth infrastructure knowledge. The proposal includes the design, implementation, and timeline for the API development. Additionally, some future functionalities are proposed to further improve user experience.

pythontensorflowkubernetes+5
Student: Hezhi Xie
Code
Proposal

Fixing fundamental issues in LLVM IR: Introducing a byte type to solve load type punning

intermediate
LLVM Compiler Infrastructure•2021Varies175h (Medium)

<p>It is common for compilers, and LLVM in particular, to transform calls to memcpy or memmove to a number of integer loads and stores of the corresponding bit width. After, load and store instructions can be optimised further. However, semantics of memcpy and memmove specify that the memory is copied as-is in bytes, and LLVM does not have a type to represent the handle to the raw memory (like unsigned char or std::byte in C/C++). This leads to incorrect transformations and miscompilations.</p> <p>This project aims at introducing a new byte type to LLVM IR to fix miscompilation issues and to make the semantics of type punning in LLVM consistent.</p>

cllvmc+++3
Student: George Mitenkov
Code
Proposal

Implementation of GitLab Data Collection Worker & Test Coverage Improvement

intermediate
CHAOSS•2020Varies175h (Medium)

<p>The primary goal of this project is to congregate data pertaining to GitLab issues, commits, merge requests amongst other entities &amp; store it into the unified data model ecosystem of Augur. The project will use a task queue, a broker and worker instances to process the information at scale. Metrics for sustainability &amp;. overall project health will be built upon the information stored in the unified model. This project also aims at increasing the overall test coverage of the project. Ergo, Unit &amp; Integration tests for data collection workers would be implemented to ensure data consistency.</p>

pythonmysqljavascript+8
Student: Saicharan Reddy
Code
Proposal

TensorFlow.js with WebWorker

intermediate
TensorFlow•2019Varies175h (Medium)

<p>The TensorFlow.js will be highly computational consuming while we are doing prediction or classification. And if such a computation happens at the UI threads, it will block all the things until the computation is done. The above will results in a bad experience while using the web to render the results and so on. And it is natural to come up with the idea that is doing a multi-threads model that let the main thread(ui thread) run for rendering UI and listen to the results from other threads and let another thread opens when the computation is needed. This WebWorker is the base for the multi-thread model over the browser. We can use the WebWorker to achieve the paradigm that separates the heavy computation apart from UI rendering.</p>

pythonc/c++machine learning+8
Student: Wenhe Li
Code
Proposal

SpliDT: Scaling Stateful Decision Tree Algorithms in P4

advanced
The P4 Language Consortium•2025Varies350h (Large)

Contemporary developments of Machine Learning Applications in real-time Networks to classify traffic for better security and performance are examples of cutting-edge research happening. This growing idea begs for an efficient framework of ML Models to adapt to needs and match the expected output, more like making a General ML Model into a Network domain-specific ML one. This project aims to adapt the SpliDT Framework, a partition-based approach for implementing decision tree inference directly in the data plane using P4. It will be optimized through TensorFlow, and HyperMapper and using Python libraries like scikit-learn.

llvmc++mlir+3
Student: Sankalp Jha
Code
Proposal

Implementation of Quantum Generative Adversarial Networks to Perform HEP Analysis at the LHC

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

This project aims to implement a Quantum Generative Adversarial Network (QGAN) using the Pennylane framework to explore the advantages of quantum machine learning in High Energy Physics. By leveraging entangling quantum circuits and variational optimization, the QGAN will be trained to model complex data distributions. The project will include a direct comparison between classical GANs and QGANs on identical tasks, evaluating performance through training speed, sample quality, and robustness to mode collapse. Deliverables include a fully functional QGAN model, benchmarking reports, noise sensitivity analysis, and an open-source code repository with documentation.

pythonmachine learningc+++2
Student: Maya Ma
Code
Proposal

Enable Context Isolation in Electron Fiddle

intermediate
Electron•2022Varies175h (Medium)

This project aims to get rid of the Node environment from the renderer process for Electron fiddle to enforce a stronger security model. Basically, with the release of Electron v12.0.0, it is now made default to set the contextIsolation as true which prevents the usage of powerful Node APIs in the renderer process. However, these changes aren’t yet reflected in fiddle’s architecture due to which it currently uses an outdated security model. Therefore, over the summer I plan to refactor Electron fiddle by migrating all the Node APIs used in renderer process to main process and later call them via IPC events.

javascriptnode.jsc+++2
Student: aryanshridhar
Code
Proposal

OrcaAL | Orca detection Active Learning tool

intermediate
Orcasound•2020Varies175h (Medium)

<p>Underwater noise pollution impedes the orcas’ ability to communicate and echolocate scarce salmon. To be able to detect orca calls, a deep learning model can be trained, but due to the lack of a vast amount of labeled data, an active learning tool is necessary.<br> This project provides an active learning web application, where the user can visualize the predictions of a deep learning binary classification algorithm on unlabeled data. Users are then allowed to annotate more data by hearing a sample and correcting its label. The project has been built in a modular way to allow the integration with different machine learning models.</p>

pythonjavascriptreact+3
Student: Diego R. Saltijeral
Code
Proposal

Expand CLI capabilities for registry management (2024 Term 1)

Intermediate
•Varies175h (Medium)

Meshery CLI is a powerful tool to manage all your cloud native resources, Meshery has internal capability called Registry to store and manage models, categories, component and relationship, presently Meshery’s v0.7 release allow users to view all this information from Mehery UI. We also need to expose Meshery’s registry capability through mesheryctl Expected Outcome: Design mesheryctl subcommands and flags for registering, listing, retrieving, updating, and deleting models, components and relationships. Implement validation and error handling for user input and API responses. Integrate with relevant Meshery APIs to interact with the registry backend.

TBA
Proposal

Add LinearModel and CompactLinearModel objects to the statistics package

intermediate
GNU Octave•2026Varies175h (Medium)

The GNU Octave Statistics package currently lacks an object-oriented framework for linear regression, missing the deep statistical diagnostics and memory-efficient deployment options found in MATLAB. This project aims to implement the LinearModel and CompactLinearModel classes to cleanly separate heavy model development from lightweight predictions. It will also modernize the fitlm function to support table inputs and Wilkinson formulas, and introduce a highly efficient stepwiselm function for automated model selection. The classes will include essential methods, extensive BIST testing, and comprehensive documentation, greatly improving Octave's statistical capabilities and MATLAB compatibility.

c++hg
Student: Avanish Salunke
Code
Proposal

Improving Test Coverage for the TARDIS Plasma Module

beginner
TARDIS RT Collaboration•2026$1.5k–$3.3k90h (Small)

The plasma module is used to determine the ionization and excitation states of the supernova ejecta using the basic structure of the supernova (elemental abundances, densities, radiation temperature). As described in the project description in the GSOC project page, CodeCov does not accurately report coverage of the TARDIS plasma. This is because the plasma module is used as a parameter for models and simulations, and is therefore indirectly tested by the tests of the simulation and model functions. While there are parts of the plasma module that are tested directly, many aspects of the module have no easy to find direct tests. This project aims to increase the test coverage of the plasma module and make the tests of the plasma modules easy to find and read.

pythonnumbanumpy+2
Student: Rishmita Rao
Code
Proposal

A Major Update for HUGE and SAM

advanced
R project for statistical computing•2018Varies350h (Large)

<p>With the recent progress in the theoretical field of sparse learning problems, current R packages are lagging behind the cutting edge research. We aim to update the current R package in order to achieve the state-of-the-art performance and equip them with various functionalities. Specifically, we will update the algorithms for estimating (1) sparse undirected graphical model with a novel active-set based second-order optimization scheme, and (2) nonparametric regression and classification model with a Newton-type blockwise coordinate descent algorithm. Furthermore, we will add inference module and sparsity induced regularization functions to the packages.</p>

cc++r+4
Student: Haoming Jiang
Code
Proposal

Implement a new WasmEdge installer in Rust (2025 Term 1)

Intermediate
•Varies175h (Medium)

Create a new tool in Rust that provides: Support cross-operating systems, including Linux(amd64 and aarch64), macOS(Intel models and Apple Silicon models), and Windows(amd64); Simplifies installation of the WasmEdge runtime and its plugins in a single tool called wasmedgeup; Automatically handles versioning, dependencies, OS/ARCH detection, and ensure the same user experience across operating systems and architectures. For more details, please refer to the upstream issue. Expected Outcome: 1. A Rust implemented installer in wasmedgeup. 2. A document to describe how to use. 3. A CI workflow to build and test on Linux(Ubuntu, Fedora), macOS, and Windows.

TBA
Proposal
Showing 2017 - 2040 of 3179 Projects
8384858687
Proposal
Proposal