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

Large Scale HEOM Solver Using PETSc

advanced
NumFOCUS•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 →
350h (Large)

This project aims to scale QuTiP's HEOM solver beyond single-node limitations by integrating PETSc to distribute ODE integration across multiple MPI ranks on HPC clusters. HEOM can exactly simulate open quantum system dynamics, but propagating a full hierarchy of coupled auxiliary density matrices makes it brutally expensive — the current scipy-based single-process implementation hits a hard wall at hierarchy depth > 6 or larger Hilbert spaces. The core design challenge is partitioning the coupled density matrices across ranks without making inter-process communication the new bottleneck. The work covers profiling the existing solver, building the distributed path on PETSc's TS interface, correctness validation against the original solver, and scaling benchmarks across node counts and hierarchy depths — all without touching the existing solver or changing anything the user sees.

pythonjavascriptr+3
Student: Chinmay Tangal
Code
Proposal

Advanced System-Level Fuzzing for OpenPrinting: Deep State Exploration and LLM-Augmented Mutation

advanced
The Linux Foundation•2026Varies350h (Large)

This project aims to transition OpenPrinting’s security infrastructure from fragmented unit-testing to a comprehensive, state-aware system fuzzing framework. While current fuzzers target isolated helper functions, they fail to exercise the deep implementation logic of complex media parsers (PDF, PCL, Raster). Utilizing AFL++, Honggfuzz, and OSS-Fuzz-Gen, I will develop API-Sequence-Based harnesses that mimic authentic user-triggered scenarios. Key deliverables include a unified consumption shim for the media pipeline, IR-based recombination algorithms for nested object abstractions, and a curated high-quality seed corpus. My preliminary discovery of a zero-day vulnerability in ipp.c (GHSA-67hg-386m-x83h) underscores the critical need for this systemic approach to harden the open-source printing ecosystem.

cpythonmysql+7
Student: Yibo Tan
Code

Improve the new git repo command

intermediate
Git•2026Varies175h (Medium)

The new git repo command doesn't handle file paths yet, and it forces users to dump all repository data at once instead of just requesting what they need. This makes scripting difficult and forces developers to keep using the older git rev-parse command. This project improves the git repo info command in two main ways: First, by adding path.* keys (like path.git-dir) that can return both absolute and relative paths. Second, by building a fast, lightweight search system (O(log N)) so users can easily query specific categories of information. As a stretch goal, the project will evolve git repo structure into a diagnostic tool by introducing metric distributions, such as object size and entry histograms.

cshell scriptgit+2
Student: K Jayatheerth
Code
Proposal

device tree bindings : Convert to DT schema

intermediate
The Linux Foundation•2026Varies175h (Medium)

A Device Tree (DT) is a data structure used to describe non-discoverable hardware to the OS or bootloader. It is written in a device tree source (.dts/.dtsi) file, which is compiled into the kernel image at build time. This structure provides a standardized way to describe a system’s hardware topology. Device Tree bindings are the rules and conventions used to describe devices within the Device Tree. These bindings define how to represent various hardware components. Device tree bindings were historically written in human readable (.txt) format and developers had to rely upon manually reading these files and writing device tree source files accordingly. Now, these files are being converted to DT schema (.yaml) format so that semantic validation can be done on device tree sources automatically.

cpythonmysql+7
Student: Bhargav Joshi
Code
Proposal

Enable clangd support for HLSL

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

The goal of this project is to enable support for the High-Level Shading Language (HLSL) in clangd, allowing shader developers to benefit from modern language-server features such as code completion, diagnostics, semantic highlighting, and symbol navigation. Although HLSL is largely based on the C++11 standard and can already be parsed by Clang, clangd’s support remains incomplete due to missing handling of HLSL-specific constructs, semantics, and resource types. Additionally, shader development introduces unique challenges, such as multiple entry points within a single file (e.g., vertex and pixel shaders), which are not fully addressed by clangd’s current architecture. The project will begin with an evaluation of clangd’s behavior on HLSL code to identify gaps, followed by the design of appropriate extensions. An RFC will be proposed to the LLVM community to validate the design and gather feedback. Based on this, the project will implement key improvements to clangd, focusing on built-in function completion, semantic analysis of shader constructs, improved diagnostics, and better handling of shader-specific configurations. The final deliverables include a documented analysis of current limitations, an RFC describing the proposed design, a structured set of implementation issues, and upstreamed improvements to clangd, along with test coverage and documentation.

cllvmc+++3
Student: Maria Fernanda Guimaraes
Code
Proposal

Search & Discovery Improvements

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

CDLI hosts over 340k cuneiform artifacts used by researchers worldwide. The current search stack runs a nightly Logstash pipeline that rebuilds the entire index from scratch, meaning approved edits can take up to 24 hours to appear in search results. Publications, collections, proveniences, and periods have no search infrastructure at all they query the database directly. This project replaces the nightly rebuild with event-driven incremental indexing using a Transactional Outbox pattern, so approved edits appear in search within minutes. It migrates the stack from Elasticsearch to OpenSearch, builds a PHP document builder to replace the existing Ruby transform, brings publications, collections, proveniences, and periods into OpenSearch, and implements cascade hooks so changes to shared entities automatically trigger reindexing of all affected artifacts. A full reindex command and admin UI, handle the initial migration and ongoing recovery scenarios.

pythonmysqljava+8
Student: harsh_dev
Code
Proposal

Scalable Email Infrastructure for CDLI Framework

advanced
Cuneiform Digital Library Initiative (CDLI)•2026Varies350h (Large)

The CDLI framework currently sends transactional emails synchronously during web requests, coupling application performance directly to SMTP availability. This project redesigns the email system into a reliable, background-driven pipeline by moving email delivery into asynchronous jobs processed by a dedicated worker. The work builds on the existing Redis and Postfix infrastructure already present in the repository, adding persistent job storage, retry logic, failure tracking, an admin monitoring dashboard, rate limiting, and a shared email template system — making email a first-class, observable part of the application rather than a side effect of user actions.

pythonmysqljava+8
Student: Sonika Chowdary Gutha
Code
Proposal

Modernizing OpenELIS Frontend with TypeScript and Performance Optimization

advanced
OpenELIS Global•2026Varies350h (Large)

The current OpenELIS React frontend is primarily written in JavaScript and faces challenges in maintainability, scalability, and performance as data complexity increases. This results in inconsistent type usage, increased bugs, and inefficient rendering in data-heavy workflows such as patient management, sample tracking, and result entry. This project aims to modernize the frontend by incrementally migrating the codebase to TypeScript and applying proven React performance optimization techniques. The migration will introduce a centralized type system for API models, forms, and reusable components, ensuring consistency and reducing duplication across the codebase. The project will follow a phased approach: first establishing a strong TypeScript foundation with shared type definitions, then incrementally migrating utilities, components, and high-impact screens. In parallel, performance optimizations will be implemented using profiling-driven techniques such as memoization, virtualization for large datasets, improved server-state handling, and code splitting. Deliverables include: - Incremental migration of frontend codebase to TypeScript - Centralized and reusable type definition system - Performance improvements in key workflows - Reduced bundle size and improved rendering efficiency - Documentation and migration guide for future contributors This project will significantly improve the maintainability, developer experience, and performance of the OpenELIS frontend, making it more scalable for future growth.

postgresqljavascriptjava+2
Student: Manroop Singh
Code

Non-Breaking Pagination & Tag Filtering for Metaflow Metadata Service

advanced
Metaflow•2026Varies350h (Large)

metadata_service returns raw arrays with no pagination or filtering. ui_backend_service in the same repository already supports both via an envelope format. Meanwhile, the DB layer (find_records, DBPagination, runs_v3_idx_epoch_ts_desc) already has everything needed — the gap is that the API layer does not expose it. This project brings metadata_service to parity: pagination via LIMIT+1, tag filtering with four operators (_tags:any/all/likeany/likeall), unified response schema matching ui_backend_service, and GIN index migration — without breaking existing clients. The key design: without _limit, behavior is identical to current. With _limit, the envelope format activates. Beyond pagination and filtering, the project also connects tag cache refresh to notify.py's existing LISTEN/NOTIFY infrastructure (debounce or incremental update strategy confirmed with mentor before implementation), and adds Content-Type header to the format_response decorator. Deliverables: metaflow-service PR covering all 9 GET endpoints, GIN index migration, feature-gating, benchmark results with EXPLAIN ANALYZE verification, backward compatibility test suite, and a pagination implementation guide for future contributors.

pythonjavascriptkubernetes
Student: EunhyeJeong
Code
Proposal

Extend support for ARM in GNU Boot

intermediate
GNU Project•2026$3k–$6.6k175h (Medium)

Computers with ARM architecture are prevalent but GNU Boot currently doesn't support them. My focus has also shifted from the classic x86_64 laptops compatible with fully free BIOS to newer armv7 and beyond to armv8 computers. The defunct fully free Libreboot has supported a few Chromebooks that didn't require blobs to boot, thanks to efforts of contributors such as PaulK. I checked with him for basic guidance and I'm in need of a mentor from the GNU Boot project under the GNU umbrella (as GSoC 2026 approved organization). Having GNU Boot support ARM computers would play well into the efforts of fully free GNU/Linux-libre distributions such as Trisquel to complete freedom-respecting ARM laptops. My work will involve updating the previous code in Libreboot and (PaulK's fork libettereboot) for the Chromebook C201 and C100 laptops and porting GNU Boot to newer ARM targets found in coreboot. Since I'm a Embedded Systems Master's student, Google Summer of Code seems to be the perfect opportunity to extend the GNU Boot contributor team while providing basic funding for taking GNU Boot to the next architecture.

cpythonposix+12
Student: f13r
Code
Proposal

Jitsi Chat Moderation and Editing System (XMPP-based Implementation)

intermediate
Jitsi•2026Varies175h (Medium)

This project aims to design and implement a complete chat moderation and editing system for Jitsi Meet. Currently, Jitsi’s chat supports basic messaging but lacks important features such as message editing, deletion, moderation controls, and search, which are essential in modern communication platforms. The goal of this project is to introduce these missing capabilities using XMPP standards like XEP-0308 (message editing), XEP-0424 (message retraction), and XEP-0425 (moderation). The implementation will follow a structured approach, starting from the XMPP layer in lib-jitsi-meet and extending to the Redux and UI layers in jitsi-meet. Key features include message editing, message deletion, moderator-controlled actions, chat muting, user reporting, message search, and reply threading. Additionally, server-side enforcement using Prosody plugins will be explored to ensure reliable moderation. This project will improve user experience, provide better control in meetings, and bring Jitsi’s chat system closer to modern messaging standards while maintaining consistency with its existing architecture.

javascriptjavaxmpp+5
Student: Alokraj@24
Code
Proposal

Capsicumize fts(3)

intermediate
The FreeBSD Project•2026Varies175h (Medium)

fts(3) is the file hierarchy traversal library used by nearly every recursive utility in FreeBSD like find, rm, ls, chflags, du, and others. It currently cannot operate inside Capsicum capability mode because it relies on path-based filesystem operations throughout traversal: opening the current directory by name, opening subdirectories by path, and resolving symlinks through constructed string paths. None of the utilities that depend on fts(3) can be Capsicumized until this is fixed. This project adds fts_openat(), a new entry point that accepts a pre-opened directory file descriptor as the traversal root, following the openat(2) convention. The existing fts_open() becomes a one-line wrapper over fts_openat(AT_FDCWD, ...), preserving full backward compatibility. The internal traversal engine is refactored to replace all path-based operations with fd-relative equivalents — openat() and fdopendir() for directory opens, dup() for CWD saves, and fstatfs() for filesystem type detection — while leaving the traversal state machine, path buffer, and cycle detection completely unchanged. The project is structured in two phases. The first and larger phase is a comprehensive ATF/Kyua regression test suite covering the complete documented behaviour of fts(3), built against the unmodified library as a safety baseline. The second phase is the internal refactoring, the new fts_openat() API, capability-mode tests using cap_enter() directly in ATF test cases, and a complete Capsicumization of chflags(1) as the end-to-end demonstration.

c/c++llvmassembly+5
Student: Jitendra Bhati
Code
Proposal

Evaluating and Enhancing Mesa's Behavioral Framework Support

intermediate
Project Mesa•2026Varies175h (Medium)

This project creates a strong, production-ready Behavioral Framework for Mesa by addressing the limits of hardcoded agent logic. Using iterative prototyping, comparing it to classic models like Sugarscape and Wolf-Sheep, and analyzing across different frameworks such as Agents.jl and GAMA, this initiative provides event-driven decision rules, lazy-evaluated states, and constraint patterns.

pythonui/uxLLMs+4
Student: codebreaker
Code
Proposal

Add support for solving systems of linear equations with LAPACK

intermediate
stdlib•2026Varies175h (Medium)

This proposal aims to strengthen stdlib’s linear algebra capabilities by implementing LAPACK-based solve routines for structured matrix formats such as packed, banded, and tridiagonal systems, which are widely used in scientific and engineering applications. The project focuses on enabling a complete factorization-to-solution workflow, ensuring seamless integration with existing routines while carefully handling specialized storage formats that require precise indexing and memory management. Emphasis will be placed on numerical correctness, consistency with stdlib’s APIs, and robustness through comprehensive testing and validation. Clear documentation and practical examples will also be provided to improve usability, ultimately making stdlib a more reliable and effective toolkit for real-world scientific computing.

cjavascriptnode.js+2
Student: Pratik Bhagwat
Code
Proposal

Python based LoRa Receiver and Demodulator with TinyGS Integration

intermediate
LibreCube Initiative•2026Varies175h (Medium)

This paper proposes a software defined radio (SDR) based ground station to receive and decode Long Range (LoRa) satellite signal, with forwarding to TinyGS and optionally LoRaWAN network. In this project a complete python package for LoRa will be implemented and used for reception and decoding. Key tasks include optimizing existing python code base written by my mentor PhD, Shayan Majumder; implementing sampling time offset (STO) and carrier frequency offset (CFO) algorithms; implementing TinyGS(MQTT) and/or optionally LoRaWAN (UDP/JSON) forwarding; establishing test, hardware in loop tests and CICD procedures; finally detailing documentation of a complete ground station.

pythonmicropythonzmq+6
Student: StudHamza
Code
Proposal

Client Library System Performance Monitoring Enhancements

advanced
Open Robotics•2026Varies350h (Large)

The ROS 2 ecosystem has made significant leaps in performance over the last few years, supported by benchmarking tools like buildfarm_perf_tests and ros2-benchmark-container. These tools take care of profiling middleware and client library performance under various configurations. As of now, the recurring monitoring path in continuous integration (CI) is mostly rclcpp-centric, providing good regression visibility for C++ implementations. However, a current limitation of the ecosystem is that it lacks periodic performance monitoring for other heavily used client libraries like rclpy (Python) and rclrs (Rust). This leaves these libraries with weaker regression visibility, making it difficult to measure the performance impact of new topologies involving remote host subscriptions or track the performance of ROS actions and services reliably. This project focuses on vastly extending the suite of tests that run regularly in buildfarm_perf_tests by porting C++ benchmark instrumentation for use with the other client library implementations. This project thus aims to add high-signal, recurring CI coverage across rclcpp, rclpy, and rclrs with minimal CI cost overhead. Furthermore, to enhance the contribution, there will also be a focus on updating the performance test result graphs in CI to use modern observability tools. The final deliverable includes an updated web dashboard (built with Grafana) that tracks key compute metrics such as latency, CPU usage, and memory over time, providing the community with a complete, cross-language performance diagnostic ecosystem.

pythonc/c++ros+5
Student: Ammaar Ahmed
Code
Proposal

Strengthening pyaslreport reliability through automated testing and CI

intermediate
Open Science Initiative for Perfusion Imaging•2026Varies175h (Medium)

The pyaslreport package currently has no automated tests for its core processing logic and no CI pipeline that runs on code changes, meaning regressions in validation behavior, parameter extraction, or report generation can go undetected until a user encounters them in a real research context. This project will build a meaningful automated test suite around the real architecture of the package and integrate it into a GitHub Actions CI workflow. The suite has two layers: an example-based integration runner that accepts a directory of input and expected output pairs and verifies the tool produces correct results for each one, and focused unit tests covering the internal normalization pipeline, schema-driven validators, M0 and TSV validation branches, file grouping logic, and sequence factory dispatch. Adding a new test case to the integration layer requires no code changes, only a new subfolder with the right files. The same runner works locally against any directory of examples and in CI against a smaller committed set, which is exactly the design Jan described in his feedback. Deliverables: an expanded test suite for pyaslreport, a committed example set covering clean, warning, error, and major error cases, a GitHub Actions workflow with coverage reporting, and a contributor guide explaining how to run and extend the tests.

pythongithub
Student: Vitor Lima Santos
Code
Proposal

Systematic Regression Test Expansion for ESP

advanced
Learning Unlimited•2026Varies350h (Large)

This project focuses on systematically expanding regression test coverage for the ESP codebase by targeting high-risk, untested logic paths rather than merely increasing overall coverage percentage. Through detailed codebase exploration, critical gaps have been identified in components such as lottery assignment logic, class registration flows, and mailman integrations. These areas involve complex logic, invariants, and edge cases that currently lack sufficient test coverage and pose a high risk of silent regressions. The project introduces invariant-based testing for the lottery system to ensure correctness properties such as no conflicts, no overcapacity, and valid grade constraints across arbitrary inputs. Additionally, integration tests will be implemented for mailman functionality using mocking to validate subprocess interactions without external dependencies. A reusable testing infrastructure will be developed to support scalable regression testing, along with targeted performance checks to detect potential degradations in critical views. The outcome will be a robust regression testing framework that transforms fragile, untested paths into enforceable guarantees, significantly improving system reliability and maintainability.

pythonjavascriptdjango+2
Student: Vipul Subhash Pandey
Code
Proposal

Ellena Mobile Prototype to Production Ready AI Assistant

intermediate
AOSSIE•2026Varies175h (Medium)

Ell-ena is already a working AI product management assistant, but it has some important limitations. It depends on external APIs for transcription, lacks a web interface, and its RAG system only works for meetings while ignoring tasks and tickets. This proposal addresses all of these gaps. I will build a responsive web dashboard that works on desktops while keeping the mobile app unchanged. I will replace the Vexa transcription API with a self-hosted faster-whisper system that runs locally at no cost and writes transcripts directly to the database. I will extend the RAG system to cover tasks and tickets, reducing token usage by 60 to 70 percent and making the AI faster and cheaper. I will also add two way GitHub integration so that tickets labeled for engineering automatically create issues and tasks get marked done when pull requests merge. Finally, I will add proper testing with CI/CD pipelines and write clear documentation for all new features. By the end of this project, Ell-ena will be a production ready web application with self hosted transcription, smarter AI responses, seamless GitHub sync, and zero reliance on paid transcription APIs.

pythonjavascriptswift+8
Student: dhruvi-16-me
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

OWASP Pulse & OWASP Contributor Recognition Program

intermediate
OWASP Foundation•2026Varies175h (Medium)

This project enhances OWASP Nest by improving visibility of activity and recognition of contributors. OWASP Pulse provides a near real-time feed that aggregates GitHub events across projects with flexible filtering. Alongside this, OWASP Contributor Recognition Program tracks and evaluates contributions using a scoring mechanism. Contributors are assigned tiers and highlighted through certificates, leaderboards, and profile enhancements.

pythonjavascriptjava+10
Student: Anurag Yadav (anurag2787)
Code
Proposal

Modernizing Haiku’s Bluetooth stack: Implementing support for HFP profile

intermediate
Haiku•2026Varies175h (Medium)

Currently, Haiku's Bluetooth stack only supports basic device pairing, with no Bluetooth profiles implemented yet. I plan to implement the Hands-Free Profile (HFP), which will enable users to connect their earphones or headphones to listen to audio and make hands-free calls. The deliverables for this proposal include working implementations of the HFP and SPP profiles, as well as RFCOMM and SCO. Additionally, the RFCOMM implementation will lay the groundwork for other profiles, such as the File Transfer Profile (FTP).

c++posixffmpeg+6
Student: Vighnesh Sawant
Code
Proposal

GPU-Accelerated VLM/VLA infrastructure on Bubbaloop

intermediate
Kornia•2026Varies175h (Medium)

This project builds GPU-accelerated image processing kernels for kornia-rs and integrates them into a real-time vision-language model (VLM) pipeline on the Bubbaloop framework, targeting the Jetson Orin Nano. The work has two pillars. First, implementing GPU kernels (resize, normalize, color conversion, cast/layout reordering) using CubeCL, eliminating CPU-GPU synchronization bottlenecks in VLM preprocessing. Second, integrating Qwen2.5-VL-3B via ONNX/TensorRT into a live Bubbaloop camera pipeline, handling dynamic resolution tiling, vision token packing, and memory-constrained inference within the Jetson's 8GB limit. Time permitting, V-JEPA 2 will also be evaluated as a complementary world model for latent scene prediction. The end result positions kornia-rs as a practical foundation for deploying vision-language models on edge devices in Rust.

cudarustdeep learning+2
Student: Siddharth Rambhia
Code
Proposal

Category Support in Nominatim

intermediate
OpenStreetMap•2026Varies175h (Medium)

Nominatim currently classifies places using a single OSM class/type pair, which causes duplicate database entries for multi-tagged objects, fragile handling of administrative boundaries, and insufficient granularity for modern search queries. This project adds native category support to Nominatim's PostgreSQL backend by introducing a categories column across the place, placex, and search_name tables using PostgreSQL's ltree[] type for hierarchical querying. Categories are assigned in the Lua import scripts following Photon's osm.<class>.<type> approach, replacing the place_classtype_* tables currently used for POI filtering. Deliverables include: schema changes with migration support for existing installations, Lua-based category assignment, replacement of classtype table lookups with category-based queries in search_name, and as stretch goals, API include/exclude filtering parameters and a flexible YAML-driven CategoryGenerator for enriched categories like cuisine.italian or access.wheelchair.yes.

javascriptjavaopengl+10
Student: Agasta
Code
Proposal
Showing 769 - 792 of 11996 Projects
3132333435
Proposal
Proposal
Proposal