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

Mass Commands

intermediate
OpenWISP•2026Varies

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)

Mass command execution in OpenWISP is currently limited to running commands on one device at a time, making it slow and difficult to manage at scale. This project introduces a bulk execution system that allows a single command to be applied across multiple devices with centralized tracking of progress and results. It will add a parent MassCommand model to group device-level executions, use Celery for parallel asynchronous processing, and maintain aggregated status such as progress, success, and failure counts. REST API support will enable programmatic triggering and monitoring of mass commands, while a redesigned admin interface will present results in a clear, scalable format with near real-time updates and access to individual device outputs.

pythonjavascriptdjango+5
Student: Deepanshu Sahu
Code
Proposal

OpenVINO GenAI: Add Image-to-Video Support to LTX Video Generation Pipeline

advanced
OpenVINO Toolkit•2026Varies350h (Large)

OpenVINO GenAI currently supports text-to-video generation via the LTX pipeline but lacks image conditioning. This project adds Image-to-Video (I2V) generation, enabling users to produce videos from an input image combined with a text prompt, running on Intel CPU and GPU. The implementation follows the HuggingFace Diffusers LTXImageToVideoPipeline reference: the input image is VAE-encoded once, and the resulting latent is prepended as frame 0 along the frame axis of the packed latent tensor throughout the denoising loop. Deliverables include: VAE encoder support in AutoencoderKLLTXVideo, a generate(image, prompt, config) overload in both C++ and Python APIs, strength-based timestep scheduling, C++ and Python samples, WWB and LLM benchmarking updates, and a cross-language test suite validating numerical consistency between C++ and Python implementations.

pythonc++x86+1
Student: goyaladitya05
Code

dora-studio: Web GUI for Dataflow Management in Dora

beginner
dora-rs•2026Varies90h (Small)

This project proposes dora-studio, a lightweight web-based GUI for viewing, editing, running, and monitoring Dora dataflows. Dora currently relies on CLI workflows, which can be less intuitive for onboarding, debugging, and demonstrations. The project will introduce a Rust-based control API to manage dataflows (list, start, stop, inspect) and a Vue-based frontend that provides a dashboard, a simple visual editor, and a live monitoring interface. The goal is to complete the full workflow loop: inspect, edit, run, and observe dataflows in a unified interface. Expected deliverables include the control API, a functional web UI for managing dataflows, a basic graph-based editor, live status monitoring, and documentation.

pythonrosc+++2
Student: Dora—DGH
Code
Proposal

Revamping CDLI Mobile App (React Native)

intermediate
Cuneiform Digital Library Initiative (CDLI)•2026Varies175h (Medium)

CDLI’s tablet applications provide access to curated cuneiform artifacts, making ancient records accessible to researchers, educators, and the public on mobile devices. This project proposes rebuilding the CDLI tablet apps as a single React Native application for both Android and iOS, integrated with the existing CDLI backend and admin panel. The app will preserve existing functionality such as browsing tablet collections, viewing high-resolution images with zoom, searching content, and accessing featured highlights, while also introducing offline support, bookmarking, and sharing. On the backend, the project will enhance the tablet feed, add structured JSON support for highlights, and enable role-based access for tablet management. With a unified codebase, the application will be easier to maintain, extend, and support for future contributors.

pythonmysqljava+8
Student: ShivaGupta
Code

StaR: A Stability-Aware Representation Learning Framework for Spatial Domain Identification

advanced
UC OSPO•2026Varies350h (Large)

Spatial domain identification is a fundamental task in spatial transcriptomics, yet state-of-the-art methods exhibit pronounced sensitivity to random initialization. Evaluating four representative methods—STAGATE, GraphST, SpaceFlow, and STcluster—across 1,000 random seeds on all 12 sections of the DLPFC benchmark reveals worst-to-best ARI ranges of up to 0.396, a gap that rivals reported inter-method differences in published benchmarks. We propose StaR (Stability-Aware Representation Learning), a plug-in training framework that addresses this limitation without modifying the base encoder architecture. As a proof of concept, our first instantiation P-StaR-A (Prototype-Anchored Adaptive Fine-Tuning) achieves a 55% relative CV reduction on STAGATE across all 12 DLPFC sections (mean CV: 11.6% → 5.2%), with the most volatile sample improving from CV = 28.4% to 1.9%. The OSRE project will extend StaR to the remaining three backbones, develop a learned cross-backbone stability gate, and release a scanpy-compatible library.

pythonc/c++visualization+5
Student: Cindy01
Code

Improving Ergonomics and Safety of serialport-rs

intermediate
The Rust Foundation•2026Varies175h (Medium)

The recent release of serialport 4.9.0 has provided an opportunity to thoughtfully plan the next major release, catching up on features that have been postponed for years which includes trait-object architecture, internal panics that manifest unexpectedly and an outdated MSRV 1.59(which was being leveled up to 1.75 recently) causing actual dependency resolution problems. This project lays the foundation for the next big release. I will start with a downstream usage audit of public dependents to guarantee that the refactoring decisions have minimal migration difficulties. This will be followed by the implementation of struct unification where backends using Box<dyn SerialPort> will be replaced with concrete structs while maintaining compile time compatibility for typical usage scenarios. Capabilities such as exclusive locking and RS485 settings will be provided using extension traits for platform specific operations. Panicking conversions such as FromRawFd will be replaced with fallible TryFrom variants. The MSRV will be bumped along with CI extension of cargo-minimal-versions.

pythonrust
Student: NONnon
Code
Proposal

Hypergraph-Based Meta-Agents for Mesa

intermediate
Project Mesa•2026Varies175h (Medium)

This proposal aims to design and implement a canonical meta-agent architecture for Mesa. The project addresses the current gap between Mesa’s experimental meta-agent support and the needs of users who want to model overlapping group structures such as households, workplaces, alliances, and teams. The work will focus on building a single canonical backend for representing overlapping typed memberships, along with a clean Mesa-facing API for creating groups, updating memberships, handling lifecycle operations, and supporting group-level state aggregation. The expected deliverables are a canonical backend, a user-facing API, lifecycle and aggregation support, tests for correctness and overlapping memberships, and documentation with example-driven validation. The result will be a stronger foundation for multi-level modeling in Mesa and a better base for future group-level extensions.

pythonui/uxLLMs+4
Student: falloficaruss
Code
Proposal

BrainGlobe: Miscellaneous maintenance work on BrainGlobe overall infrastructure (Varun)

intermediate
Neuroinformatics Unit•2026Varies175h (Medium)

This proposal aims to improve the infrastructure of the BrainGlobe ecosystem and make it easier to maintain and contribute to as it continues to grow. This will be done by simplifying the BrainGlobe meta-package API, aligning function and argument naming across tools, improving CI workflows by migrating from tox to uv, automating API documentation, and refining the conda-forge release process. Deliverables: Expose a simplified API from individual BrainGlobe tools via the meta-package. Standardise naming, arguments, and structure across tools. Migrate CI workflows from tox to uv. Improve conda-forge packaging and release setup. Automate API documentation and publishing, clean up badges and project metadata across repos.

pythonnumpypytorch+2
Student: Varun Singh
Code

1.3. Re-design the topic page

intermediate
Oppia Foundation•2026Varies175h (Medium)

This project focuses on redesigning the Oppia Topic Page to make it more intuitive and easier for learners to navigate. Currently, lessons are presented in a story-centric layout, while practice and revision content are separated into different tabs, which can cause learners to miss important activities and struggle to decide what to do next. The redesign introduces a unified interface where lessons, practice, and revision content are combined into a single continuous flow. Learners will see a structured, scrollable sequence of lesson and practice cards with clear progress indicators and actions such as start, resume, and review. It also improves how language options are displayed and selected directly on the Topic Page.

pythonjavascriptangularjs+10
Student: Kartik Suryavanshi
Code
Proposal

Adding cell creation support to afsio

intermediate
OpenAFS•2026Varies175h (Medium)

Currently, OpenAFS provides the afsio command that supports read, writes, and locks to both files and directories in the AFS environment without going through the cache manager. However, it does not support mount point control, ACL manipulation, or directory operations, which would allow a fully functional cell to be created without the cache manager; This would be convenient for administrators, as it avoids the kernel module having to be installed on the machine setup is being performed from, as well as allowing setup in environments not compatible with the kernel module. To address this problem, I will implement all three types of subcommands of afsio; Key deliverables include the code for all of these types of commands, as well as documentation such that administrators know how to use them.

cpythongit+4
Student: Junsouh Hong
Code
Proposal

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

Gabow Arborescence Packing In SageMath

advanced
SageMath•2026Varies350h (Large)

Edge-disjoint spanning arborescences are a fundamental structure in directed graph theory, with applications in connectivity and network design. SageMath currently relies on Mixed Integer Linear Programming (MILP) to compute them, which can be slow on complex instances and depends on external solvers. This project will add a native combinatorial backend based on Gabow’s algorithm, implemented in Cython and integrated into SageMath’s public API. Deliverables include validation tools, randomized regression tests, documentation, and performance benchmarks against the existing MILP-based implementation.

pythoncython
Student: Dogukan Bingol
Code
Proposal

Project 11 - Composable Kale Notebooks with Visual Pipeline Editor

intermediate
Kubeflow•2026Varies175h (Medium)

Kale compiles a single Jupyter notebook into a Kubeflow Pipeline by parsing cell tags, detecting data dependencies with PyFlakes, and generating KFP DSL. But real ML work rarely fits in one notebook ,teams split preprocessing, training, and evaluation across separate notebooks, and today there's no way to compose them through Kale without dropping down to the KFP SDK manually. This project extends Kale with multi-notebook composition and a visual pipeline editor. Each notebook declares typed inputs and outputs (KFP artifacts like Dataset, Model, Metrics or parameter types). A new workflow compiler processes multiple notebooks and compiles them into a single Kubeflow Pipeline, with each notebook becoming a KFP sub-pipeline that preserves its internal steps. A visual editor built as a JupyterLab DocumentWidget handles assembly ,drag notebooks onto a canvas, connect typed ports, compile and run. Deliverables: #1.Notebook interface declaration system (backend + frontend) — explicit typed inputs/outputs per notebook, integrated into existing NotebookConfig and the Kale sidebar UI #2. Workflow data model and .kale-workflow file format with DAG validation (cycle detection, type checking, reference resolution) #3. Workflow compiler that processes each notebook through the existing NotebookProcessor → Compiler pipeline, wraps output as sub-pipelines, and generates a top-level KFP pipeline wiring them together through artifacts #4. CLI support: kale --workflow path/to/workflow.json #5. Visual DAG editor in JupyterLab using React Flow — drag-and-drop from file browser, typed port connections, properties panel, compile/run actions via Kale's existing RPC layer #6. End-to-end tests on a real KFP cluster, user documentation, and example workflows

pythontensorflowkubernetes+5
Student: Yash_vrd
Code

Quantum Sinusoidal Kolmogorov Arnold Networks for High Energy Physics

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

The High Luminosity LHC program requires novel computational approaches to process massive datasets and identify rare signals. This project implements Quantum Kolmogorov Arnold Networks using the PennyLane framework to classify high energy physics events, such as quark gluon jet discrimination. By substituting classical linear weights with parameterized quantum circuits, we aim to benchmark the expressivity, parameter efficiency, and performance of quantum KANs against classical Multi Layer Perceptrons using CMS open datasets.

pythonmachine learningc+++2
Student: Jorge Toral
Code
Proposal

GnuCOBOL: Implement Initial Object-Oriented Programming Support

beginner
GNU Project•2026Varies90h (Small)

GnuCOBOL currently has no support for the Object-Oriented Programming (OOP) features defined by the ISO standards ISO/IEC 1989:2002 through ISO/IEC 1989:2023. Object-Oriented (OO) code currently leads to syntax errors due to lack of parsing support. The project aims to build support for parsing all OO syntax, and for a subset, also implement AST and codegen support to get a minimal working prototype of calling class methods through objects. Support for complex OOP features like method overriding and single inheritance will also be implemented. Multiple inheritance, method prototypes and parameterised classes are excluded for now. As a result, future releases of GnuCOBOL 3 will be able to parse OO code and report a simple error message about the pending feature. GnuCOBOL 4 will introduce the new paradigm to users. It will be able to generate working binaries for OO code and handle complex features like method overriding and single inheritance. The project will help bring GnuCOBOL closer to being compliant with ISO standards for OO COBOL and establish it as a significant choice among institutions looking for a free COBOL compiler with OOP support.

cpythonposix+12
Student: Saurabh Kumar (@kmr-srbh)
Code

Java 25 Language Features Support

intermediate
checkstyle•2026Varies175h (Medium)

Developers are enthusiastic about leveraging Java's latest language features, which offer more powerful, declarative, and expressive code; these features include Flexible constructor bodies (JEP 513), JEP 512: Compact Source Files and Instance Main Methods. However, Checkstyle currently lacks robust support for these features. This project aims to bridge this gap by updating existing checks and potentially introducing new ones to ensure thorough coverage of Java 25 syntax and conventions proposed by the JEPs associated with these language advancements. The objective is to deliver comprehensive support for the new language features through revising check modules, exhaustive testing, and detailed documentation updates. This effort not only aligns Checkstyle with cutting-edge best practices in the Java community but also contributes to the project's ongoing evolution

javaantlrxpath+1
Student: Vivek Singh Solanki
Code
Proposal

Benchmarking and Validation Framework

advanced
PEcAn Project•2026Varies350h (Large)

To validate ecological models against new data sources, PEcAn researchers currently bypass the rigid, database-dependent benchmarking module, instead writing fragmented, "one-off" scripts. This project solves this by replacing the rigid benchmarking module with a highly flexible, general-purpose Validation Toolkit. Built entirely on R data frames, the toolkit extracts successful design patterns from existing scripts to let users ingest arbitrary data via YAML configurations (bypassing the database entirely), align time/space, and calculate statistical metrics. The toolkit will be rigorously tested on a Biogeochemistry Minimum Viable Product (MVP) using specific AmeriFlux sites and targeted global meta-datasets. Final deliverables include the fully documented Toolkit R Package, automated Quarto reporting templates, robust test suites, and an educational tutorial vignette.

cpostgresqljavascript+8
Student: Ayushman1210
Code
Proposal

Automate template version upgrade

intermediate
Qubes OS•2026Varies175h (Medium)

Qubes OS uses TemplateVMs as the base for most application qubes. These templates track upstream operating system releases such as Fedora and Debian, which eventually reach end-of-life and must be upgraded. Today, users generally have two options: 1. Install a fresh template and manually recreate customizations and packages. 2. Perform an in-place upgrade manually by following a multi-step process across dom0 and the template terminal. The first option is safer but discards customization. The second preserves customization but is cumbersome, error-prone, and inaccessible to many users. This project proposes an automated template version upgrade workflow built on top of Qubes OS's existing update architecture. The primary deliverable is a dom0 command-line tool that performs distro version upgrades for Fedora- and Debian-based templates while preserving safeguards, reporting progress, and leaving a clear recovery path on failure. GUI integration is a stretch goal after the CLI workflow is stable and tested.

cpythonxen+3
Student: nihalxkumar
Code
Proposal

Create a new Concerto runtime for multi platform deployment

intermediate
Accord Project•2026Varies175h (Medium)

This initiative focuses first on creating a Rust runtime platform for Concerto. Presently, Concerto's runtime logic resides in JavaScript and we use Node/Browser execution to conduct that logic, however; the logic is becoming more difficult to be reused as expected in other execution environments. The long term plan is to create a reusable Validation Core written in the Rust programming language which loads Concerto entity metamodels in JSON format, validates against the requested Concerto entity types based on the appropriate input metamodel and allows both access to the same validation core as a WASM module which is used from JavaScript executed environments, and also through a native interface for callers that are not executing using vanilla JavaScript.

javascriptreactcompiler+5
Student: Yash_Kumar17
Code

Context-Aware AI Infrastructure & CI/CD-Native XOps for Open Source Governance

intermediate
AOSSIE•2026Varies175h (Medium)

This project aims to build a context-first AI infrastructure to improve how contributors, maintainers, and repositories interact in open-source development. I will design and implement a system consisting of a Skill Bot (for answering contributor queries using repository-specific knowledge), a Skill Updater (to convert maintainer discussions into structured, reusable documentation), and a PR Dashboard (to help maintainers analyze and manage multiple pull requests efficiently). These components will be connected through a shared knowledge layer, ensuring that AI assistance is grounded in real repository context rather than generic responses, while maintaining a human-in-the-loop approach for reliability and control. In parallel, I will work on XOps, a CI/CD-native infrastructure for programmable value transfer in open-source workflows. This involves building a reusable execution engine that enables secure, policy-driven payouts triggered by repository events such as PR merges. The system will support multi-chain execution, configurable policies, and auditable workflows, reducing manual accounting overhead and enabling scalable, transparent contributor reward systems. Together, these systems aim to improve contribution quality, reduce maintainer workload, and introduce a standardized, automation-first approach to both collaboration and value distribution in open source.

pythonjavascriptswift+8
Student: Karun Pacholi
Code

Integrate IRx with Apache Arrow (C Data Interface)

intermediate
Open Science Labs•2026Varies175h (Medium)

This proposal integrates IRx with the Apache Arrow C Data Interface (CDI) to enable zero-copy interoperability with systems such as PyArrow and DuckDB. Currently, IRx lacks a complete Arrow export path, supports only int32, and contains a critical issue where finish() hardcodes type metadata, leading to silent data corruption for other types. The project introduces a full Arrow lowering pipeline covering all fixed-width types and UTF-8 strings, implements a correct ArrowArray export mechanism, and resolves type handling through a generalized type_id-based runtime design. This ensures that future type additions remain localized and scalable without modifying shared logic. The outcome is a production-ready integration that allows IRx programs to exchange data directly with Arrow-compatible systems without copying or serialization, enabling its use in real-world data processing pipelines.

pythonjavascriptc+++3
Student: Jaskirats7
Code
Proposal

Unified Dark Mode and UI Consistency for Django’s Issue Tracker

intermediate
Django Software Foundation•2026Varies175h (Medium)

This project aims to bring dark mode support to Django’s issue tracker and improve its visual consistency with the main Django website. Currently, the main site supports dark mode while the Trac-based issue tracker does not, creating an inconsistent user experience. The project will implement a maintainable dark mode styling system, add a theme toggle supporting light, dark, and system preferences, and improve readability and accessibility across key pages such as tickets, reports, and wiki pages. The final deliverables include the dark mode implementation, UI refinements for important components, and documentation to support future maintenance and improvements.

pythondjango
Student: Keha chandrakar
Code
Proposal

RobStatTM-Py: Python Wrappers for Modern Robust Statistical Estimation

intermediate
R project for statistical computing•2026Varies175h (Medium)

This project will produce RobStatTM-Py, a Python library exposing the target RobStatTM function set for this project through lightweight rpy2 wrappers whose numerical outputs reproduce the R originals exactly. Every wrapper will ship with Python-style documentation modelled on the RobStatTM R man pages, a pytest validation suite, and reproducible Jupyter notebook examples.

cc++r+4
Student: Aakarshg
Code
Proposal

Implement IPP-Scan Support in go-mfp

intermediate
The Linux Foundation•2026Varies175h (Medium)

This proposal is about adding IPP-Scan support to go-mfp, OpenPrinting’s Go toolkit for multi-function printers and scanners maintained by Alexander Pevzner. Right now, go-mfp has solid IPP support for printing and a full eSCL implementation for scanning (WS-Scan is also being added). But there’s no IPP-Scan support yet, and that’s a gap. IPP-Scan (defined in PWG 5100.17) is the open standard for driverless scanning over IPP. It’s what Scanner Applications need to move away from the current eSCL-based approach. I’m proposing to build both a client and a server for IPP-Scan - the client for testing PAPPL scanner apps, and the server as a reference implementation that will also help with developing a future SANE backend for IPP-Scan.

cpythonmysql+7
Student: yogesh1801
Code
Proposal
Showing 1057 - 1080 of 11996 Projects
4344454647
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal