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

Enhancing AnyCore, a superscalar RISC-V processor

advanced
Free and Open Source Silicon Foundation•2022Varies

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)

AnyCore is an advanced superscalar processor developed at NC State University, designed to be highly configurable across parameters like issue width and pipeline depth. The goals of the project are fixing memory related issues of the core, finishing integration of an open-source Floating Point Unit (FPU), and enhancing the core in areas needed for running a Unix-like operating system.

pythonjavascriptfpga+11
Student: Gergely Bálint
Code
Proposal

Using Bayesian Optimization to tune Kubernetes application

advanced
JBoss Community•2022Varies350h (Large)

Description:Kruize Autotune is a Performance Tuning Tool for Kubernetes. . It uses Hyper Parameter Optimization to tune the language runtime layers of a given application. System component metrics can give a better look into what is happening inside them. Metrics are particularly useful for building dashboards and alerts. Kubernetes components emit metrics in Prometheus format. This format is structured plain text, designed so that people and machines can both read it.Following are four common methods of hyperparameter optimization for machine learning in order of increasing efficiency: 1.Manual 2.Grid search 3.Random search 4.Bayesian model-based optimization The aim of Bayesian reasoning is to become “less wrong” with more data which these approaches do by continually updating the surrogate probability model after each evaluation of the objective function. At a high-level, Bayesian optimization methods are efficient because they choose the next hyperparameters in an informed manner. The basic idea is: spend a little more time selecting the next hyperparameters in order to make fewer calls to the objective function. In practice, the time spent selecting the next hyperparameters is inconsequential compared to the time spent in the objective function. By evaluating hyperparameters that appear more promising from past results, Bayesian methods can find better model settings than random search in fewer iterations.So,this project aims at tuning kubernetes applications using bayesian optimization.

androidjavaide+12
Student: Prakalp23
Code

Static Program Analysis for Autograding

beginner
Submitty•2022Varies90h (Small)

Static analysis is used in the Submitty platform for verifying that the student submissions for programming courses contain specific language features. Current implementation of this uses a simple lexical (token-based) static analysis which is not up to date with the newer features in the Python language and it does not fully support C++. In order to expand these checks, the proposed solution for this is to produce and analyze the Abstract syntax tree (AST) of the submitted code. This generated AST can also be integrated with the implementation of the Lichen Plagiarism Detection module. It is also expected to create additional autograding tutorial examples and corresponding continuous integration regression testing by the end of the project.

pythonc++databases+5
Student: Poorna Gunathilaka
Code
Proposal

Proposal For Python API CLI Enhancement

intermediate
Apache Software Foundation•2022Varies175h (Medium)

The Python API CLI is a component of PyDolphinScheduler, but it currently only has two commands, `version` and `config`. This proposal refines its functionality and outlines the timelines and milestones required for refinement and follow-up plans.

pythonjavascriptjava+7
Student: lyle
Code
Proposal

CloudEvents Mapper for Eclipse Ditto

intermediate
Eclipse Foundation•2022Varies175h (Medium)

This proposal is for an out-of-the box CloudEvents mapper for Ditto which will convert incoming CloudEvents into Ditto Protocol and further look to normalize the payload. This can be done by validating the incoming headers and payload and mapping them to the defined specification. The Deliverables include: 1. Defining mapping specifications. 2. Creating an implementation. 3. Creating Unit tests. 4. Updating the documentation.

c/c++javageospatial+15
Student: Pranshu Grover
Code
Proposal

JAX ML Textbook

advanced
TensorFlow•2022Varies350h (Large)

The project will be making contributions to the PyProbML repo helping to build demonstrations and reference implementations for probabilistic machine learning models in Jax. This project will involve multiple discrete contributions of varying size and complexity aiming for a particular focus on projects involving: temporal modelling, latent variable modelling, and Bayesian factor graphs. There is also the potential to further develop the contribution I have made to the repo on restricted Boltzmann machines and contrastive divergence. This could include, for example, implementing a Deep Boltzmann Machine in Jax/Flax, demonstrating pre-training with contrastive divergence, and implementing more advanced forms of contrastive divergence such as persistent contrastive divergence.

pythonc/c++machine learning+8
Student: Giles Harper-Donnelly
Code
Proposal

RFI Mitigation

intermediate
Forschungszentrum Jülich•2022Varies175h (Medium)

This project explores the use of image analysis in a two-dimensional spectrum to detect RFI (Radio Frequency Interference) in large amounts of memory-distributed radioastronomical data. As a result, this project aims to supports and develops 1D and 2D memory-distributed convolution within the Heat domain decomposition (or data distribution) scheme.

pythonmpihigh performance computing+2
Student: Pratham Shah
Code
Proposal

imputeTestbenchG: Imputation Testbench for Genomics data

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

Data Cleaning is one of the important and time-consuming steps in the Data Science and Data Analytics field. There are numerous methods, models, and algorithms for data cleaning processes that might be categorized under imputation, outlier detections, formatting, and visualizations among others. The process of evaluating these methods for a given dataset is challenging considering the volume of the dataset and the time/space complexities of the methods. Automation of the performance evaluation process can lead to a significant reduction in human efforts and time consumption with an unbiased comparison environment. The imputeTestbench package provides a benchmarking tool for automated performance evaluation and comparison of various imputation methods for time-series datasets. In its present form, the package is capable of handling time-series and temporal datasets. Imputation plays a crucial role in the fields of genetics and genomics. The aforementioned package can be very helpful if it can be modified to handle genetic or genomics datasets. It has huge potential in handling genetic/ genomics datasets and introducing parallel-processing and high-performance computing concepts. Considering these as a motivation, the goal of the project is to develop a new R package, modifying the imputeTestbench package for Genomics applications with better computational capabilities and will be named 'imputeTestbenchG'.

cc++r+4
Student: Mayur Shende
Code

Improving Gazebo’s Mesh Format Support

advanced
Open Robotics•2022Varies350h (Large)

The project aims to extend Gazebo’s mesh loading support by either (A) Using an external open-source library or (B) Writing glTF2 and FBX mesh loaders consistent with the current approach. The new features implemented will be tested using unit and integration tests. In Phase 1, different mesh loading libraries will be collected and compared against each other and with the option of writing original glTF2 and FBX mesh loaders. The comparison metrics include but are not limited to maturity, complexity, integration difficulty, testing difficulty, and required time to implement. The report generated in this phase will be critical for the next phase and the future of the Gazebo’s mesh structure. In Phase 2, the selected approach will be implemented and tested using unit and integration tests with example worlds. Finally documentation will be created for future reference.

pythonc/c++ros+5
Student: Onur Berk Töre
Code
Proposal

GSoC Project Proposal for Flashrom

intermediate
Flashrom•2022$3k–$6.6k175h (Medium)

The write operation in flash can only change bits in a specific way and the erase operation changes all the bits of a block to 1s. So to modify any bit the whole block needs to be copied to another memory, erased on the flash, and then copied again from the other memory with the change. Due to this “erase overhead” write operations may require copying a lot of data to modify a small amount. Most flash chips support multiple erase-block sizes and flashrom keeps a list of these sizes and ranges for all supported flash chips. Currently, flashrom tries these functions one by one and uses the same function until the operation is completed or an error occurs. Usually, the first function works correctly but this function erases the smallest erase-block so flashrom would have to use it multiple times to complete the erase operation on a large region, which could have been done more efficiently using functions using larger erase-blocks, thus resulting in a transaction overhead. If a large erase-block size to erase a small region is chosen it would result in a larger erase overhead. So the erase-block size should be picked according to the size of the region left to be erased. Also checking in advance to tell if the programmer supports the given erase function and then sorting the supported functions in order of the erase-block sizes can further help the function selection.

cx86bios+2
Student: Aarya
Code
Proposal

Improving ruTorrent Mobile application

intermediate
CCExtractor Development•2022Varies175h (Medium)

ruTorrent Mobile application is a project that started 2 years ago under the organization CCExtractor Development and it's gone quite well, with the user base growing and a number of contributions being made by other developers. The aim of this project will be to implement autodl-IRSSI notification access, add Analytics and Crashlytics for better user experience, expand test coverage to cover most of the codebase and finally make a public release in the Android PlayStore and IOS Appstore.

clinuxvideo+14
Student: Mohammed Abdul Malik
Code
Proposal

Build UI Library of common components across all mobile apps

intermediate
The Mifos Initiative•2022Varies175h (Medium)

This project would focus on implementing common designs and UI elements across the Mifos apps to provide a consistent look and feel. Project goals are: 1. Develop a common UI library to ensure a consistent look and feel of UIs for all apps. 2. Define a process for migrating apps to use the library. 3. Develop design guidelines and standards for the apps. 4. Develop base-level widgets, common UI components. 5. Implement screens and workflows to test out on reference mobile app. 6. Document how to use the UI library and how to update the app when the library is updated.

mysqljavascriptandroid+5
Student: Rahul Gill
Code
Proposal

QuantumNLDiffEq.jl and Makie recipes for SciML

intermediate
NumFOCUS•2022Varies175h (Medium)

This project focuses on porting Plots recipes for SciML to Makie and adding to QuantumNLDiffEq.jl. Completion of the former would allow users to simply use Makie instead of Plots for various SciML types, while completion of latter involves adding more methods to QuantumNLDiffEq.jl.

pythonjavascriptr+3
Student: VarLad
Code
Proposal

Facets knowledge panels

intermediate
Open Food Facts•2022Varies175h (Medium)

This project aims at building an Api based on knowledge panel of Open Food Facts that return client a specific knowledge panel with use of one or two facets its Provides applications with a set of informative or actionable items which are contextual to a specific facet ,the primary goal is to allow high level contributions by users that maybe interested in a particular subset of the database, like a particular food category or a brand, a location, etc...,its reuse the knowledge panel format, which remove the need for the application to change as the server side code change, or to implement specific business logic.

androidmachine learningmongodb+6
Student: Sumit Kashyap
Code
Proposal

Railroad Diagram Creation and Implementation for Language Syntax

intermediate
Polypheny•2022Varies175h (Medium)

Currently the documentation for the Syntax of the various SQL’s that Polypheny supports has text based format which proves rather hard to read. The goal of the suggested project by Polypheny was to create a mini system which can convert the BNF like syntax in the markdown into a more visual representation in the form of railroad diagrams. With this I would like to extend the project into a large Project to apply the implementation of this Framework to the existing Jekyll Process of rendering so that it shows up as required on the website. I would also like to pursue possible extensions to improve the syntax completion and highlighting in the query console in the Polypheny-UI.

javascriptjavasql+1
Student: Jai
Code
Proposal

Journal tracker – finalise and deploy React front-end

intermediate
Open Bioinformatics Foundation (OBF)•2022Varies175h (Medium)

The project aims at helping researchers find journals that require open source code easily. I aim to create a user interface that could seamlessly help users submit, edit and delete journals and a user-management system that could help with admin and user roles. React forms can replace the outdated google forms to sign manifestos by individuals or organizations, which comes with proper authentication and spam prevention. Apart from working on having maximum functionalities integrated, I shall be removing the frontend dependencies like React-Bootstrap to make the project more user-friendly. With that, CI pipelines shall be integrated through Github actions along with E2E tests written with Cypress.

pythonjavascriptc/c+++3
Student: Padmaja Bhol
Code
Proposal

Refactoring of erddapy into separate core and object layers

intermediate
IOOS•2022Varies175h (Medium)

The erddapy package provides a Python interface to the ERDDAP data server API. Currently, most of erddapy's functionality is concentrated into a single class, and the URL building features are implemented in that class along with the data transformation methods that process server responses into Python objects, such as Pandas DataFrames. This project proposes to separate erddapy into core and object (or opinionated) layers. The former will hold the URL building and data transformation functionality, which will be reused by the rest of the library. The latter layer will provide high-level objects that will support a functional API that does not depend on the state of the underlying object (which is the case for the current version of erddapy). This functional API will provide cleaner iterative usage when querying multiple servers and datasets, and new classes implemented in the object layer will support serialization so that they can be pickled and passed on to other processes or machines. To execute this project, I delineate two separate aims: refactoring the URL building and data transformation functionality into a new module containing minimal, standalone functions and reusing those functions in the existing primary class; and implementing an additional layer containing the high-level objects that will provide the basis for the functional API. Overall, this will greatly improve the flexibility and scalability of the package, and will help support its wide spectrum of users.

pythonocean sciencejava+3
Student: Vini Salazar
Code
Proposal

Cartograms in Grapher

beginner
Our World In Data•2022Varies90h (Small)

Our World in Data (OWID) strives to make knowledge of global problems accessible and understandable through interactive geographical data visualizations to see how the world has changed over the course of time. A quick and intuitive view of the world map in relation to population makes it easy for viewers to co-relate the effect and the relative measure's gravity. OWID uses a range of choropleth maps, but size-scaled maps have downsides, primarily because human visual perception associates areas with importance. Furthermore, readily available alternatives use mosaic cartograms, which distort the shape of countries. To solve this problem, in a sentence, the primary objective is to plot a visually conclusive world map by illustrating territories/countries using a method for trading off shape and area. The basic idea of the solution is to distort the size-scaled world map while preserving the shape of countries to generate a population-scaled world map. Furthermore, a manually generated population-scaled world map acts as the reference for optimizing the cost function for better results. Finally, an option to rearrange the cells in the grid to nitpick the details yields the final result of the cartogram.

pythonmysqld3+2
Student: Adesh Nalpet Adimurthy
Code
Proposal

Per field-instance lookups

intermediate
Django Software Foundation•2022Varies175h (Medium)

Currently, lookups could be registered to a Field class which limits the versatility of Django lookups. This project adds support for lookups (building blocks to filter from a database) to be registered and unregistered for a specific Field instance (representing a field of a database table). So Field-instance-specific lookups can now be done in Django!

pythondjango
Student: Allen Jonathan David
Code
Proposal

CB-GeoMPM-NumFOCUS-XR Simulations-for-Natural-Hazards

intermediate
NumFOCUS•2022Varies175h (Medium)

The project would involve creating a pipeline from data acquisition to simulation to overlaying the visualisation in an extended reality (XR) context. Using the real world camera feed and geolocation from an augmented reality capable device, real world topography would be extracted. This data would then be used to create a simulation using material point method and then the results would be overlayed on the scene. The project would provide a prototype to identify unsafe slopes in the wild.

pythonjavascriptr+3
Student: Priyansh Jalan
Code
Proposal

Migrate Away From Protractor

intermediate
Oppia Foundation•2022Varies175h (Medium)

The Angular team plans to halt Protractor development at the end of 2022. The aim of this project is to set up the WebdriverIO with Github Actions, and complete the migration of the existing e2e tests to WebdriverIO. Also, document the usage of this new tool.

pythonjavascriptangularjs+10
Student: Shivam Jha
Code
Proposal

RcppDeepState: GitHub Action and library improvements

beginner
R project for statistical computing•2022Varies90h (Small)

Fuzzing is a useful technique for finding and avoiding programming problems by sending programs invalid sets of non-deterministic inputs. The RcppDeepState package allows developers to perform fuzz testing on libraries that use Rcpp for some specific functionalities. The main purpose of this project is to provide a custom GitHub Action that makes it simple for developers to use RcppDeepState's fuzzing techniques on any R package on GitHub. In addition, improvements to the existing RcppDeepState library will also be implemented in order to proceed with the publication of the package on CRAN.

cc++r+4
Student: Fabrizio Sandri
Code
Proposal

Rocket.Chat ReactJS fullstack Component

intermediate
rocket.chat•2022Varies175h (Medium)

The ultimate goal of the project is to create a full-stack React component node module of the RocketChat application that would be fully configurable, extensible, and flexible for use. It will allow users to integrate RocketChat into their React web-based applications easily also providing an amazing developer experience while creating in-app chat applications.

javascriptwebrtcmeteor.js+18
Student: Sidharth Mohanty
Code
Proposal

Randomized SDP solver with Riemannian Hamiltonian Monte Carlo

advanced
GeomScale•2022Varies350h (Large)

The relationship between sampling and optimization has gained increasing interest in recent years. A great number of optimization algorithms that are developed leverage sampling. The goal of this project is to equip the VolEsti library with a Riemannian Hamiltonian Monte Carlo (RHMC) sampler constrained on convex bodies and then use it for the implementation of optimization algorithms. The implemented sampler should return samples from log-concave distributions constrained in polytopes as well as spectrahedra. First of all, the initial implementation will be based on very recent promising research about an RHMC algorithm constrained in polytopes. We will expand on this effort by extending its capabilities to handle Spectrahedra. Afterwards, the above implementation will be used as a subroutine for a Semidefinite Program (SDP) solver. Last but not least, we will also include benchmark tests to compare the efficiency of our code against other state of the art libraries. As a summary, the project's deliverables will consist of the implementation of: an RHMC sampler first constrained on polytopes, then extended on spectrahedra, SDP optimization algorithms that use RHMC and finally testing against other libraries.

pythonc++r+2
Student: Ioannis Iakovidis
Code
Proposal
Showing 4489 - 4512 of 11996 Projects
186187188189190
Proposal
Proposal