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

autopkgtests for the rsync package

intermediate
Debian•2025Varies

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)

Extend the Debian rsync package autopkgtest suite by running more upstream tests, setting up end-to-end tests with a proper ssh connection, and adding new tests for so far uncovered cases.

pythonjavascriptc/c+++8
Student: puer robustus
Code
Proposal

pandemonium: GUI for cluster analysis with interactive visualization

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

The pandemonium package is a specialized cluster analysis tool designed for physics applications. It employs hierarchical clustering and provides an interactive interface for selecting tuning parameters such as distance metrics and linkage methods. The app currently includes eight analysis tabs that explore clustering solutions across two representation spaces of the same observations using techniques like parallel coordinate plots, tour visualizations, and dimension reduction. This project aims to generalize pandemonium into a more flexible, general-purpose tool applicable to any domain where cluster analysis can help uncover relationships between two connected data spaces. In addition to broadening its applicability, the project will explore and implement new visualization techniques, including interactive visualizations, slice tour visualizations, and projection pursuit within tours. By the end of the project, pandemonium will be developed as an R package and submitted to CRAN for public availability. The package will provide an accessible, interactive platform for exploring clustering solutions across connected data spaces, integrating cluster analysis and multivariate data visualization into an intuitive graphical user interface (GUI). This will significantly enhance accessibility, making these advanced analytical tools available to a broad community of users across different fields.

cc++r+4
Student: GabrielMccoy
Code

Quantum Kolmogorov-Arnold Networks for High Energy Physics Analysis at the LHC

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

This project explores Quantum Kolmogorov–Arnold Networks (QKANs) as a novel and interpretable architecture for analyzing collider data from the High-Luminosity LHC. Inspired by the Kolmogorov–Arnold theorem, QKANs decompose complex multivariate functions into compositions of univariate ones—translated into quantum models using parameterized circuits and Chebyshev-based activations. QKANs leverage quantum singular value transformation (QSVT), block-encoding, and variational unitaries to efficiently model high-dimensional, nonlinear relationships in jet physics tasks like quark-gluon tagging. The goal is to develop scalable and NISQ-compatible QKAN layers using the Pennylane framework and benchmark them against classical MLPs and spline-based KANs on realistic HEP datasets. This includes implementing quantum-friendly activation functions, evaluating noise robustness, and integrating hybrid QKAN layers selectively across high-impact features. The final deliverables will include a modular, open-source codebase, training pipelines, evaluation reports, and insights into symbolic function discovery in collider physics. This project contributes to building transparent, compact, and hardware-efficient quantum models for the next generation of scientific discovery at the LHC.

pythonmachine learningc+++2
Student: Ria Khatoniar
Code

mac_do(4) and mdo(1) improvements

intermediate
The FreeBSD Project•2025Varies175h (Medium)

The FreeBSD mac_do(4) and mdo(1) utilities enable controlled transitions of user and group credentials without relying on inherently risky setuid executables. Currently, mac_do only authorizes the /usr/bin/mdo executable, and does not fully support granular group transitions or per-jail executable authorization. This project enhances security by allowing configurable paths for authorized executables (beyond mdo), implementing granular group management via mdo(1) (new -g and -G flags), and integrating comprehensive jail support for isolating credential rules. Key deliverables include kernel-side implementation of allowed executable path lists, enhanced per-jail rule management, extended userland functionality for group management, password authentication integration, and complete documentation updates.

c/c++llvmassembly+5
Student: thesynthax
Code
Proposal

Show Variant Allele Frequency on the Plots Tab and OncoPrint

intermediate
cBioPortal for Cancer Genomics•2025Varies175h (Medium)

This project aims to enhance cBioportal's analytical capabilities by integrating Variant Allele Frequency (VAF) visualization into the Plots Tab and OncoPrint views. Currently, in Plots Tab we can visualize mutation types of particular gene across different cancer types but it is not possible to visualize VAF data for different samples across different cancer types. It is very crucial for researchers to understand mutation clonality and prevalence across cohorts through VAF. Similarly in OncoPrint view we cannot add tracks for VAF heatmaps across different genes. The proposed solution has two components. For the Plots Tab, we will introduce VAF (linked to a specific gene) as a selectable numerical data type of mutation for plot axes. Existing plot components will then automatically render Box-Scatter or Scatter plots. For OncoPrint, we will implement gene-specific VAF heatmap tracks displayed below the main alteration grid. VAF heatmaps corresponding to primary displayed mutations with a dedicated 0-1 color scale.

javascriptjavaweb+9
Student: Rishi Prasad Sulakhe
Code

grepreaper R Package Development

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

The grepreaper package addresses the critical need for efficient pattern matching and selective data loading in R, particularly for large datasets. Currently, R users must load entire files before filtering, creating performance bottlenecks. My solution implements four core functions: 1. grep_count(): Counts pattern matches without loading entire files 2. grep_read(): Selectively loads only matching data 3. grep_files(): Discovers files containing specific patterns 4. grep_context(): Shows matches with surrounding context lines The package leverages system commands for pre-filtering, significantly improving performance by avoiding unnecessary data loading. It supports flexible pattern matching options, including case sensitivity control, inverted matching, and multi-pattern support across multiple files. Deliverables include: 1. Complete R package with documented functions 2. Comprehensive test suite 3. Performance benchmarks against traditional methods 4. Introductory vignette with practical examples 5. Integration with popular data manipulation workflows This project will provide R users with a powerful tool for efficient data exploration, particularly beneficial for large dataset analysis and text mining applications.

cc++r+4
Student: Atharv Raskar
Code
Proposal

What Are We Not Archiving? A Strategic Resource Allocation Proposal for the Wayback Machine

advanced
Internet Archive•2025Varies350h (Large)

Despite capturing millions of web pages daily, The Wayback Machine may fail to archive many important resources before they disappear. This proposal outlines a comprehensive technical pipeline to optimize web archiving resources through intelligent URL ingestion, quality assessment, and prioritization. I propose a machine learning-driven pipeline that integrates diverse signal sources to identify at-risk, high-value web content while filtering low-quality material. The implementation includes a unified data collection framework, real-time quality scoring system, dynamic priority queue, and continuous evaluation mechanisms. This project, therefore, aims to significantly improve the Internet Archive’s ability to preserve historically significant web content before it potentially vanishes.

pythonjavascriptpthon+6
Student: Akshith Garapati
Code

Reactive Loan Risk Assessment Engine for Mifos

intermediate
The Mifos Initiative•2025Varies175h (Medium)

Provide financial institutions with real-time insights into loan risk, helping them make better lending decisions. A reactive backend ensures the system can handle a growing number of requests as Mifos deployments expand. Improved risk assessment can lead to more responsible lending practices, ultimately benefiting underserved communities. Create a dedicated microservice in Java that handles loan risk assessment asynchronously. Utilize reactive programming paradigms to ensure scalability and high throughput. Design and implement a configurable risk scoring model that can incorporate multiple factors such as client financial history, repayment behavior, and external credit ratings. Allow for model tuning via configuration, so institutions can adapt the scoring criteria to local requirements.

mysqljavascriptandroid+5
Student: Abhinav R Cillanki
Code
Proposal

Expanding the KDE Mentorship and Recruitment Website

intermediate
KDE Community•2025Varies175h (Medium)

The KDE Mentorship website plays a important role in onboarding new contributors to the KDE community. However, the current site lacks a modern, user-friendly UI, and doesn’t fully support KDE’s future goals of recruitment and engagement. This project aims to redesign the website into a contributor onboarding and recruitment platform. It will organize the site into clear sections: Mentorship Programs, Communication Channels, Resources, Community Engagement and Recruitment Services. The project will be built using HuGo for static site generation, Go for the backend logic such as personalized resource recommendations and contributor assessment. Deliverables include a fully responsive website which shows all the mentorship program details, resource recommendations, contributor testimonials, and a recruitment pathfinder system. This project directly aligns with KDE’s goal: "KDE Needs You" , which aims to bring more contributors into the community for next two years.

c/c++qtqml+6
Student: Anish Tak
Code
Proposal

Project 5: JupyterLab Plugin for Kubeflow

intermediate
Kubeflow•2025Varies175h (Medium)

This project addresses the issue of fragmented tools within the Kubeflow ecosystem, specifically Elyra, Kale, and Jupyter Scheduler, which complicates workflows for data scientists. The proposal aims to solve this by developing a unified JupyterLab plugin for Kubeflow. This plugin will consolidate and modernize the functionalities of the existing tools, providing a cohesive environment for developing, testing, and deploying machine learning workflows directly from JupyterLab. The plugin will achieve this by implementing seamless integration with Kubeflow Pipelines. Users will be able to convert notebook cells to pipeline steps, define and visualize pipeline workflows, submit pipeline runs, and monitor their execution status, all within JupyterLab. The plugin will be built with a modular architecture, including Python backend components for interacting with Kubeflow Pipelines and parsing notebooks, and TypeScript/React frontend components for the user interface. The key deliverables of this project are: • A unified JupyterLab plugin architecture consolidating Elyra, Kale, and Jupyter Scheduler functionalities. • Seamless integration with Kubeflow Pipelines, enabling notebook-to-pipeline conversion, workflow definition and visualization, pipeline submission, and monitoring within JupyterLab. • A user-friendly UI for pipeline development and management using modern React components. • Initial integration with Kubeflow Notebooks for easier notebook provisioning. • Comprehensive documentation and usage examples. • A robust testing framework to ensure plugin reliability, including unit tests, integration tests, user acceptance testing, continuous integration, and compatibility testing. This unified plugin is expected to significantly improve workflow efficiency for data scientists and ML engineers by bridging the gap between interactive development and production-grade ML infrastructure.

pythontensorflowkubernetes+5
Student: Amrit_Kumar
Code
Proposal

Improving Sampling in the Compositor

intermediate
Blender Foundation•2025Varies175h (Medium)

The goal of this project is to improve the compositor's sampling situation. This includes exposing the interpolation option to all nodes reliant on it. The interpolation options are already partially implemented, as seen in this issue: https://projects.blender.org/blender/blender/issues/119592. Furthermore, sampling requires boundary conditions, such as zero, extend, or wrap. Currently, these conditions are not exposed to the user, but use the wrap condition across different sampling methods. The conditions should also be selectable in the node giving more freedom to the users. Lastly, there is one sampling method that requires some special attention – BLI_ewa_filter. Currently, the EWA sampling uses different implementations across CPU and GPU, leading to different results on different devices/OSs. Blender uses EWA sampling primarily for anisotropic texture sampling. The goal is to write an implementation of the EWA filter for the CPU, which is transferable to the GPU, aiming for similar/equal results for CPU and GPU versions, allowing it to be used in the compositor to enable anisotropic compositing.

cpythonopengl+3
Student: Benjamin Beilharz
Code
Proposal

Documenting and improving cmm

advanced
Haskell.org•2025Varies350h (Large)

Cmm is the intermediate representation and code generation layer used by the Glasgow Haskell Compiler (GHC). It is written in Haskell and sits between GHC's high-level STG output and low-level native or LLVM code generation. Cmm enables multiple backends: a fast native code generator and a more sophisticated LLVM backend. In principle, this design allows users to choose between faster compilation or better runtime performance. However, like other parts of GHC, the documentation for Cmm is sparse, fragmented, and in many places outdated. For example, references to Static Single Assignment (SSA) form often describe it as "future work," even though there has been a prior attempt at implementing it. There is no cohesive documentation to explain what was done, how the backend currently works, or how one might extend it. This is an obstacle to contributors, researchers, and users alike. In practice, the LLVM backend suffers from long compile times and a fragile implementation. It depends on a custom LLVM AST that is hard to maintain, and requires users to install a specific, outdated version of LLVM. Meanwhile, the native backend is fast but unable to fully optimize performance-critical code. This project proposes to address these issues in stages: 1. Document the Cmm pipeline, the backend interfaces, and existing SSA infrastructure. 2. Then, depending on the mentor's and community's feedback, pursue one of two improvement paths:

haskellghccabal+3
Student: Diego Antonio Rosario Palomino
Code
Proposal

Enhancing ProLIF Visualizations: A Hybrid Approach for Automated, Customizable 2D Interaction Layout

intermediate
MDAnalysis•2025Varies175h (Medium)

ProLIF’s current 2D interaction diagrams often suffer from overlapping protein residues and tangled edges due to reliance on a default physics engine of vis.js. I propose to enhance ProLIF by developing an automated residue layout system that computes optimal 2D coordinates using graph-based algorithms (e.g., force-directed, radial, or circular layouts via NetworkX). This system will integrate into ProLIF’s visualization framework, allowing users to select and refine layouts interactively. Additionally, I will implement an export function to convert interaction fingerprints into a NetworkX graph for further analysis. Deliverables include a coordinate generation function, updates to the visualization module, comprehensive testing, and detailed documentation.

pythoncythonc/c+++1
Student: Nilay Verma
Code

ASL Parameters Generator from DICOM/ BIDS Images

beginner
Open Science Initiative for Perfusion Imaging•2025Varies90h (Small)

This project aims to develop a modular, open-source Python package and a web app built on it to automatically extract acquisition parameters from ASL MRI datasets in DICOM and BIDS formats and generate standardized methods sections for scientific publications. Manual reporting of MRI parameters is often time-consuming and error-prone, hindering reproducibility. This tool addresses the issue by extracting metadata, including hidden and private DICOM tags, while interactively prompting users for any missing parameters to ensure completeness. It will feature an improved DICOM/BIDS handler, an interactive graphical user interface (GUI) for parameter input and validation, and comprehensive documentation. It will also undergo beta testing with OSIPI TF4.1 members. Designed for easy integration with future extensions such as DSC/DCE MRI support, the tool will enhance transparency, save researchers valuable time, and contribute to strengthening OSIPI’s ecosystem for perfusion imaging.

pythongithub
Student: Ibrahim Abdelazim
Code
Proposal

Efficient Machine Learning Inference in Cats Effect via Scala Native and mlpack

advanced
Typelevel•2025Varies350h (Large)

This project addresses the challenge of integrating computationally intensive Machine Learning inference into responsive Scala applications without compromising service latency. Currently, ML inference within Cats Effect applications can monopolize CPU resources, starving concurrent operations. The proposed solution develops a compiler that transforms standard ONNX machine learning models into optimized Cats Effect IO operations using Scala Native for high-performance numerical computation via mlpack C++ bindings. The project will deliver: (1) C bindings for mlpack with Scala Native integration, (2) a custom Intermediate Representation for ML operations, (3) an ONNX parser, (4) a core inference library that transforms ML models into Cats Effect IO actions with strategic yielding, (5) a functional MNIST digit recognition web service demo with benchmarking capabilities, and (6) comprehensive documentation and tests. This solution will enable seamless, efficient, and purely functional ML integration within the Typelevel ecosystem without degrading service responsiveness

linuxnode.jsjvm+2
Student: Shrey Pant
Code

Incorporating AI into Template Playground

intermediate
Accord Project•2025Varies175h (Medium)

The project aims to incorporate AI features into Template Playground to facilitate the creation of Templates and Concerto models. The ability to generate Accord Project Templates from user submitted text will be implemented. Users will be able to chat with their chosen LLM and get an understanding of how the whole ecosystem of Accord Project works in tandem to produce agreements. The editors in Template Playground will be enhanced with the ability of providing AI powered inline suggestions.

javascriptreactcompiler+5
Student: Akshat-Batra
Code
Proposal

Testing & Development for Rust FreeBSD Device Drivers

intermediate
The FreeBSD Project•2025Varies175h (Medium)

The current FreeBSD environment lacks robust automated testing for Rust kernel modules and officially maintained Rust drivers. Past projects for Rust in FreeBSD started with Johannes Lundberg's Master's Thesis, where he created a RustKPI, e1000 Rust Network Driver, and a Rust kmod Hello World Example. From this, we saw Anatol Ulrich create a Hello World kernel module and a research article about writing FreeBSD kernel modules in Rust by David Young. Outside these contributions, Rust's current progress in FreeBSD is very shallow. This lack of depth makes it difficult for others to learn and build upon. I propose to analyze and extend the past work of others to assist anyone wanting to further the development of Rust in the FreeBSD kernel. My project will focus on these primary goals: 1. Creating tests in /usr/tests tree using ATF & Kyua for an existing Rust Driver 2. Use these tests to find errors in the driver logic, repairing them when needed. 3. Create a updated environment where developers can easily code and compile Rust FreeBSD device drivers. 4. Create both a Hello World driver and an Echo character driver with this environment. 6. Publishing clean and effective Rust device driver documentation for future developers to expand and work with the environment.

c/c++llvmassembly+5
Student: Acesp25
Code
Proposal

Save/Restore Window State API

advanced
Electron•2025Varies350h (Large)

Currently, Electron does not have any built-in mechanism for saving and restoring the state of BrowserWindows, but this is a very common need for apps that want to feel more native. This project aims to implement a save/restore window state API for Electron by providing a powerful configuration object called windowStatePersistence. This API will offer a declarative way to configure window persistence behavior while accommodating complex edge cases automatically. The configuration object will be optional within the BaseWindowConstructorOptions. The primary approach involves leveraging Chromium’s PrefService to store the window state as a JSON object.

javascriptnode.jsc+++2
Student: Nilay Arya
Code
Proposal

Exploring & Extending Function Calling in Gemma

intermediate
Google DeepMind•2025Varies175h (Medium)

This project aims to: (a) investigate to explore technical possibilities, enhance specifications, and find applications for specific use cases and domains, (b) create a collaborative open source site for Gemma prototypes and cookbooks for the previously identified use cases across domains, and (c) document learnings and create RFCs based on the investigations to provide a roadmap for future work.

pythonjavascripttypescript+2
Student: Vedant Kulkarni
Code
Proposal

Private Teams and Private Channels Administration Improvements

intermediate
rocket.chat•2025Varies175h (Medium)

This proposal aims to enhance Rocket.Chat’s administrative capabilities by enabling an optional override system that allows administrators to manage private teams and channels without being members. It includes configurable admin settings, permission override logic, audit logging, and user notifications to balance administrative control with user privacy. Core features include adding/removing users, modifying roles, and managing private team channels directly from the admin panel. Deliverables include backend permission logic updates, admin panel UI components, audit log infrastructure, notification settings, and full technical documentation.

javascriptwebrtcmeteor.js+18
Student: Lexie Huang
Code
Proposal

Tablet & Chromebook UI

intermediate
AnkiDroid•2025Varies175h (Medium)

AnkiDroid was initially designed for Android mobile phones. Over the years, Android has come to tablets and Chromebooks, but our UI has continued to be designed around the mobile phone. I plan to do this by implementing the following: 1. Resizable layouts for multi pane screens 2. Making a x-large note editor with previewer side by side 3. Shortcut Hints 4. Mouse Improvements 5. Optional Extensions

javascriptandroidjava+4
Student: Hari Srinivasan
Code
Proposal

URL Shortener, with a twist!

intermediate
CCExtractor Development•2025Varies175h (Medium)

Traditional URL shorteners prioritize mass sharing but often lack privacy controls. This project reimagines the concept by introducing a privacy-focused URL shortener that allows users to create both public short URLs and protected links with restricted access. Users can specify who can access a link, ensuring that the content remains private and accessible only to selected individuals.

clinuxvideo+14
Student: Vidit Agrawal
Code
Proposal

[Kvrocks] Improve the controller UI

advanced
Apache Software Foundation•2025Varies350h (Large)

Apache Kvrocks currently uses a minimalistic UI for its Controller, which limits usability and lacks advanced features. This project aims to revamp the Kvrocks Controller UI with a modern frontend stack (Next.js, Tailwind CSS) enhancing both functionality and user experience. Key deliverables include: A fully redesigned, responsive UI with clear navigation and real-time cluster visualization. Support for single sign on (SSO) authentication. Interfaces for cluster slot migration and master node failover handling. Intuitive forms and dashboards for managing instances, namespaces, and configuration. This improved UI will make it easier for developers and administrators to monitor and control Kvrocks clusters at scale, significantly enhancing the accessibility and robustness of the platform.

pythonjavascriptjava+7
Student: Agnik Misra
Code
Proposal

Dubbo triple protocol for go language implementation

advanced
Apache Software Foundation•2025Varies350h (Large)

This proposal aims to implement HTTP/3 communication for Dubbo Triple in the Go language environment, enhancing the connection management capabilities of the Triple protocol in dubbo-go. The proposal will address the compatibility issues between Triple communication in dubbo-go and dubbo-java by implementing keep-alive functionality at the Triple protocol layer. Additionally, the proposal plans to organize and standardize the error codes of the Triple protocol and output necessary log information. By developing a Triple HTTP/3 server and client, seamless and high-performance communication between Dubbo Java and Dubbo Go over the HTTP/3 protocol will be achieved. We will design a connection pool to effectively manage Triple connections and ensure the validity of connections through a PING-PONG mechanism between the server and client, thus realizing keep-alive functionality. Furthermore, the error codes of the Triple protocol will be standardized according to Dubbo Java's standards to facilitate developers in obtaining detailed log information during the debugging process. The final deliverable of the proposal is to achieve high-performance, barrier-free communication between Dubbo Go and Dubbo Java through the Triple protocol, ensuring perfect compatibility and support for interaction via the HTTP/3 protocol. Users will be able to enjoy flexible keep-alive functionality and improve debugging efficiency through standardized error codes.

pythonjavascriptjava+7
Student: marsevilspirit
Code
Showing 1825 - 1848 of 11996 Projects
7576777879
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal