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

Develop a Golang-based framework to enhance Knative’s functionalities

intermediate
JBoss Community•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 →
175h (Medium)

<p><a href="https://knative.dev/" target="_blank">Knative</a> is an open-source community project that extends Kubernetes with modules for deploying, operating, and maintaining serverless, cloud-native applications. The serverless cloud computing model has the potential to improve developer efficiency while decreasing operating costs.The project idea is to develop Charmil, an open-source Golang-based platform that will serve as a package manager which assists in the discovery and installation of plugins from a community-curated plugin index. These plugins can then be embedded into any host CLI with additional features such as new version detection and smooth upgrades.Through Charmil, each CLI will be able to install other CLIs as extensions, thereby organizing them in a hierarchy. This functionality of Charmil will later be used to add new features on top of the Knative CLI.</p>

androidjavaide+12
Student: Namit Chandwani
Code
Proposal

Pitivi Timeline Ruler: Native GTK4/Rust Rewrite

intermediate
GNOME Foundation•2026Varies175h (Medium)

The Pitivi timeline ruler currently relies on a legacy Python implementation using GTK3 and the Cairo drawing model. As Pitivi updates to a modern GTK4 native structure, the CPU-heavy Cairo draw calls are becoming a bottleneck for rendering time markers and frames at varying levels of zoom. This project will rewrite the ruler as a standalone, native GTK4 widget using Rust and ‘gtk-rs’. By moving away from Cairo and utilizing GTK4’s hardware acceleration via ‘GtkSnapshot’ and Render Nodes, the new ruler will be significantly more performant and memory-safe. Following a modular design philosophy, the widget will be built independently with a robust GObject API before being integrated into Pitivi’s existing Python and GStreamer Editing Services (GES) infrastructure using GObject introspection.

cpythonjavascript+4
Student: Michael Calabrese
Code
Proposal

Improve Metric Module

beginner
NumFOCUS•2021Varies90h (Small)

<p>PyTorch-Ignite is a great library built on top of pytorch. It provides an extremely simple engine and event system to work with, which work really well in a distributed environment. It also has a set of very handy metrics which can be used right out of the box. This is why I would like to become a contributor for the PyTorch-Ignite library. I wish to work on the metrics module because I have worked in Brain-Computer Interface, Computer Vision, Augmented Reality and am familiar with a myriad of different metrics. I am also familiar with using pytorch library and have built, trained and tested many models with it, making me a suitable candidate to work on the metrics module of PyTorch-Ignite. Contributing to PyTorch-Ignite can help me learn more about using pytorch in a distributed environment, writing test cases for your code, get used to the GitHub workflow in general.</p>

pythonjavascriptr+3
Student: Arpan Parikh
Code
Proposal

DigiKam Image Quality Sorter Algorithms Improvement

intermediate
KDE Community•2022Varies175h (Medium)

The main idea of IQS in digiKam is to determine the quality of an image and convert it into a score. This score is based on four criteria which are factors sabotaging image: blur, noise, exposure, and compression. The current approach is useful to determine images distorted by one of these reasons. However, the current algorithm presents also some drawbacks : It demands a lots of fine tuning from user's side and it's cannot work on aesthetic image. So, I propose the solution of deep learning algorithm. While the dataset and the paper for aesthetic image quality assessment are free to use, we are capable of constructing a mathematical model that can learn the pattern of a dataset, hence, predict the score of quality. As deep learning is an end-to-end solution, it doesn’t require the setting for the hyperparameters. Hence, we can reduce most of the fine-tuning parts to make this feature easier to use

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

Adding eBPF profiling capabilities to Sysprof

advanced
GNOME Foundation•2025Varies350h (Large)

This project aims to enhance Sysprof by integrating eBPF-based profiling to reduce overhead and improve performance. Currently, Sysprof relies on accessing numerous /proc files, which involves frequent syscalls, file descriptor operations, and context switches, creating performance bottlenecks. By utilizing eBPF, data collection can be done directly within the kernel, eliminating the need for constant /proc access and minimizing context switches. This approach not only lowers overhead but also ensures consistent and atomic data capture. eBPF also allows for advanced features such as system-wide syscall monitoring and process creation tracking, which were difficult to implement previously. By adopting eBPF, Sysprof becomes more efficient, scalable, and feature-rich, laying the foundation for future enhancements and transforming it into a modern, versatile profiling tool.

cpythonjavascript+4
Student: Varun R Mallya
Code
Proposal

Neural Network Builder API Refactor

intermediate
NumFOCUS•2026Varies175h (Medium)

The sbi (Simulation-Based Inference) library currently constructs neural density estimators via opaque factory functions that accept loose keyword arguments. This design leads to delayed validation errors crashing deep inside PyTorch rather than at configuration, tangles data preprocessing (Z-scoring) with model architecture, and prevents experiment configurations from being serialized, making reproducibility difficult for researchers. This project will refactor the neural network builder infrastructure into a modular, three-tier Layered API. By transitioning to strongly-typed Python dataclasses, the new API will introduce DensityEstimatorBuilder for fail-fast validation and a fully decoupled ZScoreConfig to isolate data standardization. This object-oriented approach ensures that invalid configurations are caught immediately and allows architectures to be easily inspected and saved.

pythonjavascriptr+3
Student: Satwik Sai Prakash Sahoo
Code
Proposal

Garbage Collector Redesign and Integration

advanced
Boa•2026Varies350h (Large)

Boa is an embeddable JavaScript engine written in Rust. JavaScript is garbage collected by specification, meaning the runtime is responsible for managing memory and reclaiming values once they become unreachable. Boa's current collector (boa_gc) works and is well tested, but it was designed for correctness first, and now carries design debt that holds back performance and maintainability. Experimental redesign work is already underway in the separate Oscars repository. This project focuses on evaluating that work, auditing the current design, improving the GC where needed (tracing strategy, allocation model, rooting) and integrating a production ready collector into Boa's runtime, backed by stress tests, benchmarks and documentation covering the design decisions and tradeoffs. Extensions may include incremental or generational collection, GC aware VM optimizations and heap visualization tooling.

javascriptrust
Student: shruti.dev
Code
Proposal

Implement vector mode in forward mode automatic differentiation in Clad

intermediate
CERN-HSF•2023Varies175h (Medium)

In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation. The AD library is able to differentiate non-trivial functions, to find a partial derivative for trivial cases and has good unit test coverage. Vector mode support will facilitate the computation of gradients using the forward mode AD in a single pass and thus without explicitly performing differentiation n times for n function arguments. The major benefit of using vector mode is that computationally expensive operations do not need to be recomputed n times for n function arguments.

pythonc/c++machine learning+6
Student: Vaibhav Thakkar
Code

4diac IDE: Improving the Reliability of the Graphical Editors for Eclipse 4diac

intermediate
Eclipse Foundation•2024Varies175h (Medium)

The 4diac IDE is an extensible, IEC 61499 compliant engineering environment for distributed control applications. The current state of its graphical editors presents challenges, as they timely result in poor user experience and frequent errors. To overcome these issues, there is a strong need to introduce an automated test suite specifically for the graphical editors. These test suites will detect errors that will enhance the overall reliability of the editors. Through automated testing, we can effectively implement error indicators within graphical models, ensuring timely identification and resolution of issues. With that, these test suites will provide support to features characterized by deep hierarchical nesting, which directly complicates interaction within the graphical editors. By systematically addressing these challenges, we aim to significantly improve the usability and reliability of the graphical editors within the 4diac IDE.

c/c++javageospatial+15
Student: Prashantkumar Khatri
Code

Develop MCP Server for Agentic AI interaction with OpenCost (2025 Term 3)

Intermediate
•Varies175h (Medium)

We would like OpenCost to more effectively integrate with AI agents. To do this, we need to implement a Model Context Protocol (MCP) server to surface the information from the OpenCost API. This is a great opportunity to learn about MCP servers, and help us build an interface for AI agents to obtain reliable cost/usage information so that they can accomplish their business goals. Expected Outcome: We would like an MCP server integrated into OpenCost. This MCP server should support queries on allocations, assets, and cloud costs. The MCP server should support the full range of allocations, assets, and cloud cost query parameters. A demo video should be recorded showing an interaction with the MCP server, and used to obtain costing information in a conversational setting. In addition, integration tests must be created in the OpenCost Integration Tests repo that test all interactions with the MCP server.

TBA
Proposal

Add statistics and machine learning functions to Boost.uBLAS

advanced
Boost C++ Libraries•2018Varies350h (Large)

<p>Boost.uBLAS employs numerous compile-time optimizations which improve the performance of matrix operations. However, there is no implementation of any application on matrices which can exploit this performance - like mean, variance, factorization etc. Providing some such fundamental functionalities for vectors and matrices in a single package would be a great addition to the uBLAS library. The goal of this project is to lay out the foundation of uBLAS to support basic statistical analysis methods and machine learning algorithms. More specifically, I am interested in implementing the following fundamental components:</p> <ul> <li>Basic statistics</li> <li>Running statistics</li> <li>Histograms - with custom number of bins and edges</li> <li>KMeans clustering</li> <li>Principal Component Analysis (PCA)</li> <li>Gaussian Mixture Model - Expectation Maximization</li> </ul>

c++c++11c++14+3
Student: Dattatreya Mohapatra
Code
Proposal

Report Aggregation for Compliance

intermediate
FOSSology•2026Varies175h (Medium)

Managing compliance today means juggling dozens of independent reports - SPDX, CycloneDX, CLIXML, ReadmeOSS - generated separately for each component, with no way to merge, track, or evolve them as a whole. This project introduces a Report Aggregator Tool for FOSSology and SW360 that consolidates multiple compliance reports into a single, authoritative document. Users will be able to select reports across formats, merge them through a transparent aggregation UI, inspect and edit the combined data with full traceability, and propagate changes incrementally when source reports are updated. With seamless integration into FOSSology’s agent framework and SW360’s project hierarchy, this tool will transform fragmented compliance artifacts into unified, audit-ready documentation - making FOSSology an even more complete solution for meeting regulation like the EU Cyber Resilience Act

linuxpostgresqlc/c+++7
Student: Harshit Gandhi
Code
Proposal

Bug Connector Proposal

intermediate
C2SI•2024Varies175h (Medium)

The proposal describes an initiative to create a public dataset using publically available Common Vulnerabilities and Exposures (CVE) information. The major purpose is to compile complete data points from multiple sources, add to the dataset, and make it publicly available. The proposal identifies obstacles in correlating commit IDs to CVEs and proposes using timing analysis, NLP approaches, and real-time monitoring to address these issues. The project is separated into two stages: collecting data for existing commits and CVEs and making the system real-time. The implementation strategy involves data collection, correlation algorithm creation, integration of NLP techniques and offline LLM models, and real-time system installation. The deliverables include a comprehensive CVE dataset, correlation techniques, NLP integration, and a real-time monitoring system.

pythonjavago+2
Student: Joy Zawadi
Code
Proposal

Website Modernization Migration from Jekyll to Hugo

intermediate
preCICE•2026Varies175h (Medium)

The preCICE website is built on Jekyll with several Ruby gems that have become difficult to maintain (many of which have been abandoned) and cause frequent build failures for contributors. The goal is to move the site to Hugo (a static site generator built on Go), which handles most of what these plugins do out of the box. This means porting layouts from Liquid to Go templates, upgrading from Bootstrap 3.3.7 to Bootstrap 5, and restructuring content to fit Hugo's model. All existing URLs and external documentation integrations will be kept intact during the transition. Deliverables include a fully functional Hugo site, rewritten CI/CD workflows, Algolia search via JSON output, and sub-repo mounts replacing Jekyll submodules. By the end, any contributor should be able to clone the repo and build the site in one command, with no Ruby setup required.

cpythonshell+1
Student: Aashir
Code
Proposal

Enhancing LLM Training Efficiency with Clad for Automatic Differentiation in C++

advanced
CERN-HSF•2025Varies350h (Large)

Training Large Language Models (LLMs) is computationally expensive, often bottlenecked by the performance limitations of Python-based frameworks. This project addresses this challenge by enhancing LLM training efficiency within a C++ environment through the integration of Clad, a Clang/LLVM compiler plugin for automatic differentiation (AD). We will deveop a custom C++ tensor library specifically designed for optimal interaction with Clad. The core objective is to replace traditional runtime or manual gradient computations with Clad's efficient compile-time differentiation for key LLM operations within a GPT-2 training pipeline. This involves investigating effective strategies to bridge Clad's static analysis with dynamic neural network computations, benchmarking the resulting performance gains in speed and memory usage against a non-Clad baseline, and leveraging OpenMP for further parallelization.

pythonc/c++machine learning+6
Student: Rohan Timmaraju
Code

xeus-haskell -- GHC/Wasm Backend Integration Prototype

intermediate
Haskell.org•2026Varies175h (Medium)

This project aims to integrate the official GHC/WebAssembly backend into xeus-haskell, a Jupyter kernel for Haskell. Currently, the kernel relies on MicroHs, which, while lightweight, lacks support for the vast majority of the Hackage ecosystem. I will implement a dual-backend architecture by introducing a new C++ bridge and a reactor-model Wasm REPL module based on the GHC API. Key deliverables include: GhcRepl: A GHC-based WebAssembly REPL module maintaining persistent session state. C++ Bridge: A new interface (ghc_repl.cpp) to communicate with the GHC/Wasm runtime via the Wasm C API. Backend Abstraction: A unified virtual interface to allow seamless switching between MicroHs and GHC/Wasm. WASI Integration: A configured browser shim to handle I/O and package database access within JupyterLite

haskellghccabal+3
Student: Arman Sanjay Choudhary
Code
Proposal

Cloud-Edge Speculative Decoding for LLM via KubeEdge-Ianvs (2024 Term 3)

Intermediate
•Varies175h (Medium)

The autoregressive decoding mode of LLM determines that LLM can only be decoded serially, which limits its inference speed. Speculative decoding technique can be used to decode LLM in parallel with the help of draft model, so as to improve the inference speed of LLM without loss of accuracy. However, the speculative decoding technology of LLM does not consider the application in the cloud-edge distributed environment. This project aims to implement cloud-edge collaborative speculative decoding based on KubeEdge-Ianvs, an open source cloud-edge collaborative distributed machine learning platform, so as to further improve the LLM inference speed in cloud-edge environment. Expected Outcome: - Implement an example of cloud-edge collaborative speculative decoding based on KubeEdge-Ianvs platform. - (Optional) Propose a more efficient cloud-edge collaborative speculative decoding algorithm.

TBA
Proposal

Scancode.io/Scancode Toolkit: Create web application to scan and review a single license text

beginner
AboutCode•2022Varies90h (Small)

Create a web app and JSON Rest API to detect any text for license, and submit bugs (SCTK-aaS). This project is to create a web-based mini application to be plugged in ScanCode.io as a new Django app with its own model that would receive a text as an input and run ScanCode Toolkit license and copyright detection on this text. It would display the results such that the matched texts and all matching details are easy to understand and make it visually obvious what was matched and how it was matched. It should also allow to easily provide feedback if the detection is not correct, and suggest a better detection and possibly the creation of a new license detection rule. It should also integrate and run the "scancode-analyzer" https://github.com/nexB/scancode-analyzer/ to find possible issues automatically. Finally it should allow the report of a license detection easily and integrated in the app based on the results.

pythonjavascriptc/c+++6
Student: lf32
Code

Multilingual Projections of Semantic Frames and Frame Elements using Modified Existing Parsers and Neural Networks

intermediate
FrameNet Brasil (UFJF)•2020$3k–$6.6k175h (Medium)

<p>My proposal aims to accelerate future semantic annotation projection research by creating two main deliverables. First, before the GSoC 2020 starts, I intend to complete a Python API for retrieving the annotation dataset. Throughout the GSoC 2020, I will modify existing parsers and create neural networks to project semantic frames and frame elements to unannotated sentences. I mainly work with projections on the manually aligned sentences and aligned sentences generated through transitivity. In addition to suggesting techniques for tackling m:n alignment, I also propose metrics for evaluating the projections in binary and graded manners as well as a phraseological method for analyzing projections for metaphorical phrases. If time permits, I would create sentence alignment models for aligning EN-JP, EN-FR, EN-UR, and EN-HI sentences.</p>

pythonmysqljavascript+1
Student: Zheng Xin Yong
Code

RooFit - Pythonic interaction with the RooWorkspace

intermediate
CERN-HSF•2023Varies175h (Medium)

RooFit uses RooWorkSpace to manage its models. Currently, the syntax to interact with RooWorkspace is completely different from Python syntax, which makes the code less intuitive & harder to manage. The project aims at making the interaction with RooWorkspace more Pythonic. Pythonization RooWorkspace is done in two main steps: 1.) Writing a C++ plugin for the RooWorkspace factory 2.) Writing Pythonizations This is followed by making unit tests, writing documentation & writing tutorial for the new Pythonic interaction. The deliverables for this project are: ● Develop a Pythonic alternative to RooWorkspace::factory() ● Pythonization of special operations of RooWorkspace along with support for creating Histfactory p.d.f.s using the JSON I/O ● Write unit tests to check the functionality of Pythonic code ● Make tutorials to demonstrate the usage of new functions in Python & improve documentation for HistFactory

pythonc/c++machine learning+6
Student: Yash Solanki
Code
Proposal

CppSharp / Maintenance & Improvement tasks

intermediate
Mono Project•2017Varies175h (Medium)

<p>CppSharp is a tool and set of libraries which allows programmers to use C/C++ libraries with high-level programming languages (such as C#). It is a tool that takes C/C++ header and library files and generates the necessary glue to surface the native API as a managed API. Such an API can be used to consume an existing native library in your high-level code or add scripting support to a native codebase. The supported target languages at present are C# and C++/CLI. It can also be used as a library to parse native code into a syntax tree with a rich declaration and type information model. This, thus, demands a lot of improvements and maintenance tasks as per the feedback from the users over the course of time. So, I'll try to fix as many bugs as I can and add as many new useful features that I can.</p>

cc#.net+1
Student: Mohit Mohta
Code
Proposal

MAKE IT EASY TO ADD AND UPDATE UNIT TESTS

beginner
Stichting SU2•2025Varies90h (Small)

This project aims to automate and expand SU2’s testing and validation framework to ensure both numerical correctness and physical fidelity. By sourcing benchmark test cases from public databases (e.g., NASA Turbulence Modeling Resource), we will develop scripts to automatically generate configurations, run simulations, and compare SU2 results against experimental data. Key outputs like lift, drag, and pressure coefficients will be visualized and stored for regression tracking. These validation tests will be integrated into SU2’s CI pipeline, enabling automatic execution, reporting, and performance benchmarking. Additional efforts include modularizing unit tests, improving test coverage, and providing clear documentation for future contributors. This will greatly improve SU2’s reliability, usability, and trust within the CFD community.

pythonc++
Student: Harsh@2004
Code
Proposal

AI Face Recognition with OpenCV DNN module

advanced
KDE Community•2019Varies350h (Large)

<p>digiKam is KDE desktop application for photos management. In digiKam, tags on photos are strongly supported for the sake of providing users with a natural workflow of searching and arranging photos in their collections. Since many of our photos contain faces, face tag has apparently emerged as an essential property for any photos management software, also with the fact that user has to tag thousand of their photos manually. Being aware of that, digiKam team has put a lot of efforts to develop face engine, capable of scanning photos and suggesting face tags automatically basing on pre-tagged photos by users. However, that functionality is currently deactivated in digiKam, as it is slow while not adequately accurate. Thus, this project aims to improve the performance and accuracy of facial recognition in digiKam by exploiting state-of-the-art neural network models in AI and machine learning.</p>

c/c++qtqml+6
Student: Thanh Trung Dinh
Code
Proposal

AI Tour Director: An Omni-Agent System for Liquid Galaxy

beginner
Liquid Galaxy project•2026Varies90h (Small)

AI Tour Director reimagines geographic visualization as a cinematic experience by treating every tour like a film. There is a set of specialized agents that collaborate to transform a simple user prompt into an immersive tour. Creative Director, Production Designer, Writer, Auditor, and DOP make this magic happen. Each agent contributes to building a cohesive narrative, that is, from selecting locations and designing camera movements to generating narration and validating the flow. The system leverages modern AI and real-time geographic data to direct immersive tours on Liquid Galaxy, complete with synchronized visuals, subtitles, and multilingual narration. It further enables recording these experiences as high-quality videos and turns the exploration into shareable film-like content. The final deliverable is a modular agent-driven platform that blends storytelling, visualization, and open-source extensibility.

javascriptrosgis+14
Student: Kabir Khanuja
Code
Showing 2737 - 2760 of 3179 Projects
113114115116117
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal