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

Integration of TMVA and OpenML platform

intermediate
CERN-HSF•2017Varies

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 →
175h (Medium)

<p>OpenML is an open source project that aims to create a novel ecosystem for machine learning experimentation. It is possible to integrate different machine learning tools through plugins and APIs to share datasets, experiments and results in the platform. The idea is to write an OpenML’s plugin in Java for ROOT, that allows the use TMVA in OpenML, and also create an C++ API for TMVA that permits the use of OpenML tools from within ROOT.</p>

pythonc/c++machine learning+6
Student: Sami Ullah
Code
Proposal

Loklak apps/microservices to the open tweet platform loklak.net and IoT integrations using the loklak backend

intermediate
FOSSASIA•2016Varies175h (Medium)

<p>loklak is free software hosted on loklak.org which provides message search results from twitter in json format. loklak is a complete search engine back-end solution with a json api. Loklak’s API can be used to build twitter clones and client alike, one of them being loklak.net. One of the main features that’s pending in such a tool is the ease of adding angular micro services and modularizing the existing application to run on micro services. Alongside the data store of loklak is magnificent and provides the ability to build IoT platforms using the loklak server. In this proposal I would like to enhance the service architecture of loklak.net and build a proof of concept IoT application demonstrating the capabilities of the loklak server.</p>

pythonjavascriptandroid+7
Student: Sudheesh Singanamalla
Code

GSoC 2016 EXPONENTIAL INTEGRATORS

advanced
GNU Octave•2016$6k–$13.2k350h (Large)

<p>I propose a project about the implementation of some Exponential Integrators. Exponential integrators are a class of numerical methods for the solution of partial and ordinary differential equations. This class of methods is based on the exact integration of the linear part of an initial value problem and this can help to mitigate the stiffness of a differential equation. My idea is to implement at least four methods, the two basic methods exponential Euler and exponential Rosenbrock-Euler, and then two advanced methods with adaptive time stepping, one from Runge-Kutta and one from Rosenbrock-type exponential integrator family. This is my initial idea, but I'm willing to take advice and expand the project during the work period. I want to implement the methods as m-file so an implementation of this type should go into odepkg.</p>

c++hg
Student: Chiara Segala
Code
Proposal

HTTP Streaming

intermediate
Ruby•2026Varies175h (Medium)

This project addresses the absence of HTTP streaming support in the Rage framework, where responses are currently fully buffered before being sent to the client. This limitation prevents real-time use cases such as incremental LLM outputs, live data feeds, and large streaming responses. Even when applications generate data in chunks, the Iodine server collects all output into a buffer and sends it only after completion, making true streaming impossible. To solve this, the project introduces native HTTP streaming using chunked transfer encoding across both Iodine (C layer) and Rage (Ruby layer). A new streaming path will be added to Iodine to support incremental writes with a robust backpressure mechanism, ensuring the event loop remains non-blocking. On the Rage side, a developer-friendly API (render stream:) will be implemented using enumerators and fibers, allowing applications to stream data declaratively while seamlessly handling pause/resume behaviour under backpressure. The deliverables include implementing the http_stream transport, a Rack-compatible streaming writer with lifecycle and backpressure management, and the Rage streaming API. The project will also provide integration tests, edge-case handling (e.g., disconnects, high load), and updated documentation. This enables real-time streaming in Rage while preserving compatibility and supporting future extensions like HTTP/2.

rubycjava+3
Student: Piyush-Goenka
Code
Proposal

Extending Rule-Based Symbolic Integration

advanced
SymPy•2026Varies350h (Large)

Symbolic integration is one of the central capabilities of any advanced calculator system e.g. Mathematica. SymPy currently provides several integration strategies including heuristic methods, algorithmic approaches such as the Risch algorithm, and a rule-based integrator implemented in sympy.integrals.manualintegrate. The manualintegrate module performs integration by recursively applying pattern-based rules similar to how integrals are solved manually. While this approach produces readable step-by-step results and supports a wide range of expressions, its current rule coverage is limited and many integrals involving special functions or structured products are not recognized. The goal of this project is to extend the rule-based integration system in manualintegrate, focusing on improving support for special functions, structured products, and rule prioritization. The project will expand the set of integration rules, improve heuristics for rule selection, and ensure better compatibility with SymPy's symbolic simplification system. The approach is to first analyze the gaps between manualintegrate and more comprehensive rule-based systems such as RUBI in order to identify missing classes of integrals and structural weaknesses. Based on this analysis, the project will design SymPy-compatible rule representations using its existing pattern-matching framework, ensuring consistency with the current architecture. New rules will then be implemented incrementally, with each addition accompanied by rigorous testing and validation to guarantee correctness and stability. Throughout this process, particular attention will be given to preserving and extending SymPy’s step-by-step explanation capability, ensuring that all newly supported integrals remain interpretable and aligned with human-style symbolic reasoning. The end goal is to make SymPy’s integrator more complete, explainable, and closer to human-style symbolic reasoning, while maintaining correctness.

pythonc++numpy+1
Student: SalahDin Rezk
Code
Proposal

Consolidate and advance the GPU infrastructure in Clad

intermediate
CERN-HSF•2026Varies175h (Medium)

Automatic Differentiation(AD) is a set of techniques to evaluate the derivative of functions specified by a computer program. Clad is a Clang-based automatic differentiation tool that transforms C++ source code to compute derivatives. Clad have demonstrated promising support for GPU-based differentiation through prior efforts involving CUDA, Thrust, and integrations with applications such as XSBench and LULESH. However, all this works remains fragmented and inconsistently tested. This project aims to consolidate the fragmented work and advance Clad’s GPU infrastructure into a robust and consistent system.

pythonc/c++machine learning+6
Student: Vedant Goyal
Code
Proposal

BOA Constrictor: Benchmarking Neural Backbones for HEP Data Compression

advanced
CERN-HSF•2026Varies350h (Large)

The LHC at CERN generates 30 petabytes of physics data every year. Current compression tools like LZMA treat this data like any other file and miss the statistical patterns unique to particle physics. The BOA Constrictor solves this by training a neural network to predict the next byte more accurately inside an entropy coder. The original BOA paper proved the concept works (4.03x compression on CMS data vs LZMA's 3.22x), but two gaps remain: Mamba doesn't install on Python 3.12, and nobody has compared alternative architectures under fair conditions. This project will build a benchmark suite comparing GRU, LSTM, MinGRU, Transformer, and Mamba under parameter-matched conditions. It will then optimize the best backbone using INT8 quantisation, pruning, and distillation, producing Pareto frontier plots showing compression ratio vs model size. Finally, it will explore physics-informed priors as an auxiliary loss to improve predictions. All code and results will be contributed back to the upstream BOA repository.

pythonc/c++machine learning+6
Student: Akarsh_sahlot
Code

Modernizing rs_loader: Migrating to Latest rustc Internals with HIR-based Extraction

intermediate
MetaCall•2026Varies175h (Medium)

This project aims to modernize MetaCall's rs_loader by migrating it to the latest rustc compiler internals. The current implementation relies on outdated APIs, making it incompatible with newer Rust versions. The project will focus on updating compiler integration, replacing AST-based traversal with HIR-based extraction, and adapting to changes in rustc_driver and related components. The approach includes analyzing breaking changes, incrementally migrating core modules (lib.rs, middle.rs, ast.rs), and ensuring compatibility with modern Rust toolchains. Deliverables include a fully working rs_loader compatible with the latest rustc version, improved type and function extraction using HIR, and updated documentation for maintainability.

pythonjavascriptc/c+++6
Student: Satvik Upadhyaya
Code

istSOS Role-Based Web Administration

intermediate
OSGeo (Open Source Geospatial Foundation)•2026Varies175h (Medium)

This project adds proper role-based access control to istSOS4 by making the web administration interface reflect the permissions already enforced in PostgreSQL through Row-Level Security (RLS). Right now, the backend enforces access correctly, but the UI does not — every user sees the same controls. This project fixes that. Each role (administrator, editor, viewer, sensor) will only see the pages and actions they are allowed to use. It also simplifies user and policy management by removing the current two-step workflow. Creating or updating a user will automatically apply the appropriate policies, reducing configuration mistakes and making the system easier to operate. To support real deployments, the project adds basic observability and debugging tools. A permission matrix shows what each role can do, and audit logs record access-related events. In addition, small utilities like permission explanation, access simulation, and change impact preview help admins understand and verify changes before applying them. The project also explores integration with external authentication providers (OIDC) so istSOS4 can work with single sign-on setups, including Grafana, without changing how permissions are enforced. Overall, the focus is to make permissions visible, predictable, and manageable for administrators.

pythonjavascriptc/c+++4
Student: Kinshuk Sanand
Code
Proposal

Enhancing a FHIR Resource Tabular Viewer for Efficient Data Exploration

advanced
Data for the Common Good•2026Varies350h (Large)

FHIR resources are powerful but difficult to explore in practice because their data is deeply nested, inconsistent across resource types, and hard to analyze in raw JSON form. This project will enhance the existing FHIR Resource Tabular Viewer to make healthcare data easier to search, filter, and interpret for researchers, clinicians, and developers. I will improve the transformation layer that maps nested FHIR structures into stable, readable table columns, strengthen exploration features (global search, column filters, sorting, column visibility, and row-level drill-down), and extend ingestion support to additional sources, specifically local files and Amazon S3. Key deliverables are: (1) an improved and more reliable FHIR-to-table transformation pipeline for common resource types (2) upgraded table exploration and visualization workflows (3) modular data-source support for local and S3-backed datasets (4) performance improvements for larger datasets (5) expanded automated tests and documentation. The final outcome will be a more scalable, maintainable, and user-friendly viewer for real-world FHIR data exploration.

pythonjavascriptkubernetes+2
Student: O-Abdelaziz
Code

VMM Accelerator support for QEMU

advanced
The FreeBSD Project•2025Varies350h (Large)

This project aims to add VMM acceleration support to QEMU on FreeBSD, bridging the gap between QEMU’s userspace emulation and FreeBSD’s kernel-based VMM hypervisor. Currently, QEMU on FreeBSD lacks hardware acceleration, forcing users to rely on slower TCG emulation or switch to bhyve. I plan to modify QEMU’s memory management to work with VMM’s kernel-allocated guest memory. Additionally, I will adapt VMM to make non-critical devices (HPET, RTC) optional, letting QEMU handle them in user space. This would enable a hybrid interrupt model (kernel vLAPIC + emulated IOAPIC). The deliverables for this project would be a working -accel=vmm backend for QEMU. I will also add some changes to VMM, allowing some of the in-kernel devices to be made optional. Finally, I will add comprehensive documentation and benchmarks for the libvmmapi interface. This will enable near-native performance for QEMU on FreeBSD, expanding virtualization options while maintaining compatibility with existing QEMU tooling.

c/c++llvmassembly+5
Student: Abhinav Chavali
Code
Proposal

PyUVM-Based General Testbench for RISC-V Cores

intermediate
Micro Electronics Research Lab - UITU•2025Varies175h (Medium)

With the increasing adoption of RISC-V as an open-source Instruction Set Architecture (ISA), there is a growing need for effective and reusable verification methodologies. While Traditional verification methodologies struggle with variability of RISC-V cores leading to extensive testbench modifications, our project resolves this by leveraging the RISC-V Formal Interface (RVFI) and PyUVM making UVM-based verification more accessible to a broader audience.

RISCVProcessorHardware+2
Student: Nitin Grandhi
Code
Proposal

Using AI for Unicode Spoof Detection

intermediate
Unicode, Inc.•2025Varies175h (Medium)

Attackers can exploit homoglyphs, or visually similar characters, to perform social engineering attacks or evade spam and plagiarism detectors. Unicode contains over 200 writing systems (scripts). Many of these scripts, such as Latin (in western Europe) and Cyrillic (in eastern Europe), contain characters that are look-alikes. This project aims to develop an AI tool to detect confusable characters and ultimately improve Unicode security mechanisms automatically.

javac++rust+1
Student: Om Doiphode
Code
Proposal

Apache NuttX Apps and Rust Integration

beginner
Apache Software Foundation•2024Varies90h (Small)

The integration of Rust into Apache NuttX, an embedded Real-Time Operating System (RTOS) used across various platforms from 8-bit to 64-bit, aims to enhance the security and reliability of IoT applications. Rust, known for its safety and memory integrity, is seen as a promising solution to address vulnerabilities in IoT systems, such as buffer overflows and memory corruption. The project involves studying Rust for embedded systems and "no_std" environments, creating coding guidelines for Rust in NuttX, and developing a guide for these standards. It starts with converting simple NuttX applications, like the LED Blinky App, to Rust, gradually moving to more complex applications. The deliverables include implementing Embedded Rust, C Interoperability, and Heap Memory Allocation in Rust, porting the LED Blinky App from C to Rust, and testing it on various Single-Board Computers. The project also aims to merge these items into NuttX Mainline as Pull Requests and add workarounds for NuttX's rustc build process. Documentation will cover a coding standard for Rust, setting up a local environment for Rust build, configuring NuttX to work with Rust, and building Rust firmware with NuttX.

pythonjavascriptjava+7
Student: Rushabh Gala
Code
Proposal

Containerization of CBACK backup system

intermediate
CERN-HSF•2024Varies175h (Medium)

The project aims to enhance CERN Storage's backup orchestration system, CBACK, by introducing a Scheduler Agent to dynamically manage job agent creation based on service demand. Leveraging database triggers for real-time responsiveness, the Scheduler Agent will analyze changes in the internal database and spawn agents as needed, boosting scalability. Moreover, modifications will enable containerization of existing agents, facilitating seamless integration with Kubernetes-based environments. Additionally, enhancements will enforce scope limitations within file mounts using cephx keys to strengthen security and control over data access. Comprehensive documentation of all changes will ensure smooth adoption and maintenance.

pythonc/c++machine learning+6
Student: YashrajSingh
Code
Proposal

Triage and Categorize Kubeflow GitHub Issues & PRs

intermediate
Kubeflow•2024Varies175h (Medium)

The main goal of the project is to find a solution to categorize issues and PRs in the Kubeflow Github repository. There are a lot of issues and PRs in the repository. They have to be merged or closed with less human interaction as quickly as possible. The project is based on the Issues/PRs of the https://github.com/kubeflow/kubeflow Github repo. There are 218 issues and 219 PRs for now. The features that needed to be included in the solution should be - Decide which Issues/PRs are still relevant - Categorize Issues/PRs by type - De-duplicate multiple Issues for the same request - Suggest which ones are the most important. - Help find “good first issues” for new members - Review which PRs are likely safe to merge (especially dependent ones) The planned solution is to create an application to add the above features into the application by providing automated solutions for all of these features. The proposed application provides automated tasks to fulfill the above requirements so that the issues and PRs can be resolved with less human interaction.

pythontensorflowkubernetes+5
Student: Hansini Karunarathne
Code
Proposal

Move out of gogo/protobuf to protobuf with vtproto implementation

advanced
CNCF•2024Varies350h (Large)

We propose transitioning from the deprecated gogo/protobuf to Vitess's vtproto as part of an effort to modernize Prometheus's codebase. The migration requires minor changes to the original code structure. However, agent-side performance degrades significantly by around 50% according to cstyan’s experimental results. While manually serializing the data structure can avoid these allocation overheads, we prefer not to maintain hand-written marshal/unmarshal code. The upcoming Remote-write-2.0 (rw2.0) will address these memory allocation overheads. By pushing for rw2.0 alongside migrating to vtproto, we can utilize a better-maintained library and eliminate this allocation if rw2.0 is adopted quickly. Therefore, I propose that we manually marshal/unmarshal protobuf while pushing for rw2.0's publication.

gorustkubernetes+3
Student: tonyli233
Code
Proposal

Vaquita Vector Coprocessor

advanced
Micro Electronics Research Lab - UITU•2024Varies350h (Large)

Summary The project aims to enhance Nucleus RV Core by adding the RISC-V Vector Extension (RVV v1.0) as a co-processor. Key objectives include developing basic RVV functionalities, collaborating on design with project maintainers, integrating the co-processor into Nucleus RV, and ensuring seamless operation. The project contributes to open-source hardware innovation and improves Nucleus RV's performance for vector-intensive tasks. deliverables The following deliverables are considered at the time of writing which may be possible for further changes or improvements. 1) Implemented RISC V Vector configuration instructions in Vaquita Co-Processor 2) Implemented RISC V Vector configuration instructions in Vaquita Co-Processor 3) Implemented RISC V Vector configuration instructions in Vaquita Co-Processor 4) Implemented RISC V Vector configuration instructions in Vaquita Co-Processor 5) Developer documentation and end user documentation for RISC-V Vector Vaquita Co-Processor.

RISCVProcessorHardware+2
Student: Mohammad Latif
Code
Proposal

[SunPy] HelioViewer Python API Wrapper

intermediate
OpenAstronomy•2022Varies175h (Medium)

The Helioviewer Project is developing a suite of technologies that allow users around the world to visualize, browse and access these heterogeneous datasets in a highly customizable fashion. They do so by providing public APIs to the developers. In sunpy, we can query to Helioviewer API to get those data, with the help of a HelioviewerClient instance that can be used to make HTTP requests and manipulate the results as required. The current HelioviewerClient in sunpy does not offer full access to the Helioviewer API and is limited to a few endpoints. But the Helioviewer API has a huge number of endpoints that provide different functionality, the current implementation doesn’t integrate with Fido (sunpy’s search and download interface) and the HelioviewerClient doesn’t belong to sunpy’s core and needs to be moved out of the codebase. This project will we wrapping every aspect of Helioviewer API in a Python package and extend its support to Fido with the help of a new client.

cpythonjulia+7
Student: Akash Verma
Code
Proposal

enviroCar App: Voice Command

intermediate
52°North Spatial Information Research GmbH•2022Varies175h (Medium)

Having your phone with you in your car is useful for a lot of reasons and enviroCar helps in the same way. But at the same time, it’s also a potentially dangerous distraction to use your phone while driving. Similarly interacting with the enviroCar Android app while driving is a serious concern, as it may result in an accident if the driver is distracted. This is why adding voice command features to the app has become a must feature. Hence This summer I will be working on automating the enviroCar application’s actions via voice commands to provide a user-friendly experience.

javascriptandroidjava+2
Student: Dhiraj Chauhan
Code
Proposal

Make Deepchem More Robust: Implement Cutting-Edge Models and Other Features

advanced
Open Chemistry•2021$6k–$13.2k350h (Large)

<p>Deepchem is one of the premier open-source deep learning libraries for chemistry. It is used by people worldwide, thus there is a need to develop and provide access to updated cutting-edge models, more metrics and tests for model performance evaluation and more recently developed loss functions. My GSoC ‘21 Project proposal is to add the Molecule Attention Transformer and a protein structure model to Deepchem and/or Jaxchem.</p>

pythonjavascriptopengl+7
Student: Atreya Majumdar
Code
Proposal

Enhancing PathwayMapper in cBioPortal and PathwayMapper editor

beginner
National Resource for Network Biology (NRNB)•2020Varies90h (Small)

<p>Pathways are created by selecting certain genes and studies then displayed in the PathwayMapper tab in the cBioPortal. However, not every page in cBioPortal has a direct link to PathwayMapper hence making inferences from specific pages and reflecting the outcome to PathwayMapper is not straightforward. In order to overcome the struggle to interact between the pages and pathways, a PathwayMapper tab will be incorporated into Study View, Patient View, and Comparison pages. To test the implementations, I will deploy cBioPortal to Heroku so that I can test the code and ensure that it works in a remote server. PathwayMapper is used to construct pathways however pathways can become very complex and hard to understand as the data mounts. Some features are expected to be implemented in PathwayMapper to decrease the complexity of pathways and make it easy for users to draw conclusions. Features expected to be implemented are Expand-collapse operations, Hide-show operations, Filtering, Highlighting. For PathwayMapper editor features I will use functionalities that are already implemented in the Cytoscape.js. Bugs in Collaborative Mode will be fixed.</p>

pythonjavascriptjava+11
Student: Merve Kılıçarslan
Code

LACE-View : A Visualizer for Longitudinal Clonal Trees

advanced
National Resource for Network Biology (NRNB)•2020Varies350h (Large)

<p>LACEview is a visualization tool for LACE (Longitudnal Analysis of Cancer Evolution) developed by a team at BIMIB. The tool is for R visualization and uses htmlwidgets and other R packages to output an informative and well optimized ourput that is user interactive.</p>

pythonjavascriptjava+11
Student: Bhavesh Narra
Code
Proposal

OpenEXR: Separate Imath Repository Proposal

intermediate
Academy Software Foundation (ASWF)•2020Varies175h (Medium)

<p>This project entails the separation of OpenEXR's Imath library into its own repository. This will allow for it to be used by other projects and provides an opportunity to refine Imath itself. It houses a number of issues currently including: narrowed casting, incomplete testing, sporadic const omissions, and other exceptions.</p>

pythonc/c++
Student: Owen Thompson
Code
Proposal
Showing 6241 - 6264 of 13453 Projects
259260261262263
Proposal
Proposal
Proposal
Proposal
Proposal