Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters
13453 Projects Found
Sort by

Friendly gamified learning app for p5.js

intermediate
Processing Foundation•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)

An offline-first gamified learning mobile app for p5.js that teaches users how to use the library’s symbols (functions, constants, classes, etc.) through small exercises. Inspired by Google's Grasshopper app.

pythonjavascriptandroid+6
Student: prjctimg
Code
Proposal

LG Interactive Onboarding: Guided Tutorial & Learning System for Liquid Galaxy

advanced
Liquid Galaxy project•2026Varies350h (Large)

The Liquid Galaxy ecosystem currently faces an unstructured and fragmented onboarding process. Crucial development information is scattered across various wikis and forums, leading to a steep learning curve and persistent architectural rule violations by new developers. Furthermore, the absence of an interactive sandbox makes it difficult for contributors to safely experiment with code and receive instant feedback, while advanced capabilities like 3D KML modeling remain heavily underutilized due to a lack of guided, hands-on tutorials. LG Interactive Onboarding radically overhauls contributor training by transforming the Liquid Galaxy rig itself into an immersive, interactive classroom. Operating on a "phone-as-driver, rig-as-canvas" philosophy, the system uses a smartphone application as a remote control to project educational content, live code exercises, and data visualizations directly onto the rig's 5-screen panoramic display. The platform integrates multi-modal learning—combining animated visual diagrams, auditory voice narration, and kinesthetic hands-on coding—with a privacy-conscious, on-device Gemini AI Mentor. This enforces core development best practices from day one and significantly reduces the manual onboarding workload for organization mentors.

javascriptrosgis+14
Student: Darpan Baviskar
Code

AVX2-Accelerated Collision Detection for Real-Time MPC in Humanoid Robotics

advanced
OpenVINO Toolkit•2026Varies350h (Large)

This project aims to resolve the computational bottleneck in self-collision detection within the OCS2 framework for humanoid robotics. The current implementation in ocs2_self_collision operates on a pair-by-pair basis, iterating through collision pairs and calling PinocchioGeometryInterface::computeDistances() followed by Jacobian and penalty term calculations. This sequential approach is not SIMD-friendly by default and fails to utilize the parallel processing power of modern CPUs. To address this, I propose replacing the current computeDistances()-based distance computation with a high-performance implementation inspired by SIMD-amenable structures. A primary focus will be exploring / integrating SIMD-friendly data structures, such as Collision-Affording Point Trees (CAPT), to represent the storage and computation of collisions. This transition aims to transform the collision pipeline into a vectorized workflow that can be efficiently accelerated using AVX2 intrinsics. The primary deliverables include the clean integration of this accelerated engine into the ocs2_self_collision pipeline, accompanied by rigorous correctness checks against Pinocchio/FCL baselines. Furthermore, I will provide a comprehensive end-to-end latency evaluation using ocs2_mobile_manipulator to demonstrate the reduction in average and maximum compute cycle times. This work will significantly enhance the real-time performance of MPC-based humanoid control in complex environments.

pythonc++x86+1
Student: asterich
Code

Support X86 Process Context Identifiers (PCID) in COCONUT-SVSM

intermediate
QEMU•2026Varies175h (Medium)

COCONUT-SVSM is a Secure Virtual Machine Service Module running at a privileged level inside Confidential VMs to provide trusted services (e.g., virtual TPM) independent of the host hypervisor. Currently, the SVSM kernel performs full TLB flushes on every context switch, discarding all TLB entries indiscriminately and causing significant runtime TLB miss overhead. This project enhances COCONUT-SVSM to leverage the x86 PCID (Process Context Identifiers) hardware feature to tag TLB entries per task, preserving them across context switches and enabling selective TLB invalidation. The work is structured in three phases: Phase 1 builds a code-generated Rust crate (x86-cpuid) from the authoritative x86-cpuid-db v2.4 XML database, replacing all scattered, magic-bit-position CPUID checks across the codebase with a type-safe cpu_has(leaf_0x1::ecx::Pcid) API unified across SNP, TDX, and native platforms via a CpuidReader trait. Phase 2 designs and implements a PCID assignment strategy for all virtual pages in the COCONUT kernel, enabling the CPU to tag TLB entries per task(same for all threads of task) and preserve them across context switches. Phase 3 converts global TLB flush operations in into selective, PCID-aware invalidations: using AMD's INVLPGB broadcast instruction to flush a specific PCID across all cores without IPIs. Key Deliverables are x86-cpuid Rust crate with code generator consuming x86-cpuid-db XML, refactored COCONUT-SVSM codebase with all open-coded CPUID checks replaced with new code generated by x86-cpuid Rust crate, PCID allocator, applying the PCIDs in the COCONUT page-tables and selective TLB flush functions (flush_tlb_pcid, flush_tlb_range_pcid) with AMD INVLPGB.

cassemblykvm+4
Student: Tanish Desai
Code
Proposal

Foundation models for End-to-End event reconstruction

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

This project aims to develop a multi-modal foundation model training pipeline for end-to-end particle reconstruction in the CMS experiment. Building on last year's LorentzParT hybrid architecture (L-GATr + ParT) and its track-level masked autoencoder pretraining, I will design a unified tokenization scheme encoding particle kinematics and interaction features as distinct modality streams, and pretrain the shared encoder using a novel Cross-Modal JEPA objective that predicts masked token embeddings across modalities in latent space — combining, for the first time, JEPA-style self-supervision with Lorentz-equivariant representations. The pretrained encoder will be fine-tuned and benchmarked on multiple downstream tasks including event/jet classification and mass regression, with conditional generation as a stretch goal. Deliverables include the complete CM-JEPA pretraining pipeline, a multi-modal tokenizer, multi-task fine-tuning scripts, systematic ablation studies across pretraining methods and masking strategies, trained model checkpoints, and an open-source repository with documentation and a blog post.

pythonmachine learningc+++2
Student: Suryansh Mishra
Code

Improvements on L5 Documentation and Starter Flow

beginner
Processing Foundation•2026Varies90h (Small)

This project will focus on L5: expanding on existing L5 tutorials, documentation, and building integrations with existing editors so that creatives can seamlessly start building in L5. The focus of the documentation updates will include updating community statements (such as principles of permacomputing), adding clarity to first-time start-up and examples, creating and fleshing out new tutorials, ideally helping both those new to Lua or new to coding.

pythonjavascriptandroid+6
Student: sam heckle
Code
Proposal

Visual Studio Code plugin for CScout

beginner
Open Technologies Alliance - GFOSS•2026Varies90h (Small)

I'm building a VS Code extension that brings the power of CScout’s whole-program C analysis directly into the editor. My goal is simple, let developers understand large C codebases more effectively without ever leaving VS Code. Using this extension, one will be able to browse identifiers, find all references, explore call graphs, check metrics, and even preview refactorings in the IDE itself. We will have to extend CScout by adding a clean REST/JSON API on top of the SWILL web server. This API will be the bridge to let external tools (like my VS Code extension) query the data from CScout in a structured way.

pythonmysqljava+7
Student: Ujjwal Aggarwal
Code
Proposal

Qt Integration Tests

intermediate
VideoLAN•2026Varies175h (Medium)

This project aims to expand the Qt Integration Tests by adding tests for Keyboard navigation, playback controls, playlist management, and other UI elements. Improve CI integration in Linux for better stability, and explore running the tests on Windows for VLC 3.

copenglc+++10
Student: Yousef Kenawy
Code
Proposal

Live-patching for the FreeBSD kernel

intermediate
The FreeBSD Project•2026Varies175h (Medium)

This project aims to add a livepatch subsystem to dynamically update kernel code. Having a way to patch bugs or security vulnerabilities without restarting the whole machine would be very useful, especially on servers, which make up the majority of FreeBSD usage. Patches will be delivered via kernel modules, utilizing ELF headers and CTF/DWARF metadata to accurately resolve internal symbols. The patching mechanism will redirect control flow by inserting trampolines at the prologue of target functions. To ensure system stability, patches will be safely applied using a stop-the-world consistency model via smp_rendezvous, with safeguards to prevent the modification of critical routines like the SYSINIT routines. Stack trace analysis will also be explored to more accurately detect function quiescence.

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

Improve CVE - Derivation Matching Accuracy, Data Integrity, and Observability in the Nixpkgs Tracker

intermediate
NixOS Foundation•2026Varies175h (Medium)

This project focuses on improving the accuracy, reliability, and observability of the Nixpkgs Security Tracker by addressing key limitations in its current CVE–derivation matching pipeline. At present, the system relies on overly permissive substring-based matching, incorrect string-based version comparisons, and lacks proper monitoring, which leads to noisy results, missed vulnerabilities, and silent failures. The proposed work introduces a structured, test-driven redesign of the matching pipeline. It replaces flawed string comparisons with semantic versioning to ensure correct handling of version boundaries. It also improves matching quality by incorporating multiple signals such as trigram similarity, CPE-based matching, and version constraint filtering, thereby reducing noise and increasing the precision of candidate derivations. In addition, the project strengthens data integrity and consistency by fixing cache update issues, eliminating race conditions in issue generation, and ensuring that the system always reflects the latest state after manual or automated changes. It also introduces observability through metrics and dashboards, making system behavior measurable and exposing previously hidden failure cases. Finally, the proposal removes hardcoded infrastructure by enabling dynamic, database-driven channel selection, improving maintainability and scalability. All improvements are guided by measurable metrics and validated through tests to ensure correctness and prevent regressions. Overall, the project aims to deliver a more accurate, robust, and transparent security tracking system for the NixOS ecosystem.

gitnix
Student: Darshan Thakare
Code
Proposal

Rice Farm Agriculture India Visualization

intermediate
Liquid Galaxy project•2026Varies175h (Medium)

This project proposes an interactive geospatial storytelling platform that visualizes rice agriculture across india using the liquid galaxy multi-screen visualization system. Rice is one of the most important crops in India, and understanding its geographical distribution, seasonal cycles, irrigation patterns, and production trends can help students, researchers, and the public better understand agricultural systems.

javascriptrosgis+14
Student: Vinayak_Dhaka
Code
Proposal

libgomp Optimizations for Scheduler Guided OpenMP Execution in Cloud VMs

advanced
GNU Compiler Collection (GCC)•2026Varies350h (Large)

Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.

cc++openmp+3
Student: Nchang Roy
Code

GA4GH-aligned Trustworthy Federated AI

intermediate
Global Alliance for Genomics and Health•2026Varies175h (Medium)

This proposal addresses the deployment gap in federated learning for genomics, where frameworks like FLAN enable distributed model training but lack standardization, security, and interoperability required for real-world biomedical environments. As a result, federated learning systems remain difficult to deploy across institutions and cannot scale in regulated settings. To solve this, the project transforms FLAN into a GA4GH-aligned, production-ready federated AI system by integrating key standards across the stack. It incorporates DRS for secure and standardized data access, TES/WES for portable and reproducible task and workflow execution, and TRS for containerized tool discovery. Security is strengthened using GA4GH Passports and Attested TLS for zero-trust, identity-aware communication, while Model Context Protocol (MCP) is introduced to enforce privacy constraints and execution policies across federated nodes. The deliverables include a refactored FLAN pipeline with DRS-based data access, modular training workflows executed via TES, end-to-end orchestration using WES (CWL/WDL/Nextflow), containerized environments registered with TRS, integrated Passport-based authentication and Attested TLS communication, a prototype MCP-based policy enforcement layer, and comprehensive documentation with a GA4GH-compliant reference implementation.

pythonjavamongodb+10
Student: Vidit Khandelwal
Code

BLT Next

beginner
OWASP Foundation•2026Varies90h (Small)

BLT-Next proposal covers the full migration from Django monolith to static frontend on GitHub Pages with Cloudflare Python Workers at the edge. The core idea is simple migrate all the Django services/features into modular independent services, Which reduces the cost to $0/month.(using free services like cloudflare worker and github pages). BLT-Next is the reset. Everything static services goes to GitHub Pages, anything that needs server logic gets a Cloudflare Worker, with database suppport from cloudflare D1.

pythonjavascriptjava+10
Student: Md Kaif Ansari
Code
Proposal

Enhanced World Editing

intermediate
Tiled•2026Varies175h (Medium)

World editing in Tiled is functional but minimal. Resizing maps requires a dialog, creating new maps means leaving the world view, and standalone maps can't use world tools at all. This project adds four core improvements: a world grid for coarse snapping, drag handles for visual map resize, creating and deleting maps directly in the world view, and a default world so standalone maps get world tools.

githubc++qt+1
Student: Kanishka0411
Code
Proposal

CARTopiaX: Extending a Next-Generation Platform for Computational Cancer Biology

intermediate
CERN-HSF•2026Varies175h (Medium)

This project proposes a comprehensive strategy to extend the CARTopiaX platform within BioDynaMo to replicate a wider range of in vitro observations relevant to CAR T-cell therapy in solid tumors. By incorporating additional agents, microenvironmental factors, and interaction rules, combined with robust parameter calibration strategies such as Bayesian optimization and evolutionary algorithms, the enhanced model aims to capture critical dynamics that influence therapeutic outcomes, providing a flexible and powerful tool for in silico hypothesis testing. If successful, the extended CARTopiaX model will serve as a reliable platform for exploring CAR T-cell therapies and has the potential to generate high-impact insights in computational cancer biology. By bridging experimental data with predictive modeling, the project could accelerate the translation of in silico findings into actionable guidance for experimental and clinical research.

pythonc/c++machine learning+6
Student: Salvador de la Torre Gonzalez
Code

Benchmark Polytope Import Suite For Volesti

beginner
GeomScale•2026Varies90h (Small)

This project aims to develop a Benchmark Polytope Import Suite for the volesti library, enabling automated conversion of standard Linear Programming instances and metabolic network models into H-Polytopes compatible with volesti. A user-friendly CLI tool will allow researchers to perform conversions easily without directly interacting with the code. Additionally, a curated benchmark collection with regeneration scripts will support reproducible testing and demonstration of the pipeline. The project will follow best software engineering practices, including, unit, integration and end to end tests, as well as comprehensive documentation and tutorials. By providing a robust and easy to use import suite pipeline, this project will expand volesti's accessibility and usability for researchers in volume approximation and sampling of convex bodies.

pythonc++r+2
Student: JimmysPavlou
Code
Proposal

Compositor: New Nodes from Geometry Nodes

advanced
Blender Foundation•2026Varies350h (Large)

As highlighted during the 2025 Blender Conference, one of the primary challenges facing the Compositor is managing complexity. To address this, the goal of this proposal is to make it as accessible as possible by porting over familiar nodes from Geometry Nodes. This project aims to: - Develop a future-proof classification between the two modules. - Port matrix & math utility nodes into the Compositor: Matrix SVD, Bit Math, Boolean Math, Integer Math, Compare, Float To Int, Hash Value, and Random Value. - Extend GPUType to include boolean, integer and integer vector types. - Ensure UI and behavior consistency between ported nodes and existing ones, including full support for the GPU Compositor. - Implement regression testing for all newly ported nodes. - Document the rationale behind node selection, implementation and functionality in the new context.

cpythonopengl+3
Student: Criss-Ivana
Code
Proposal

Lightweight TotalSegmentator Integration for CT & MRI Anatomical Segmentation in InVesalius

intermediate
Invesalius•2026Varies175h (Medium)

This project tackles the challenge of limited anatomical segmentation in InVesalius by integrating TotalSegmentator through a lightweight inference pipeline using pre-exported JIT and ONNX models. The approach uses nnU-Net-based models to automatically segment 117 CT structures and 80 MRI structures: organs, bones, muscles, and vessels; without requiring nnunetv2 or any heavy dependencies. Users select specific anatomical structures from a categorized checklist and receive color-coded masks directly within InVesalius's existing visualization, editing, and 3D export pipeline. This enables clinicians in resource-constrained hospitals to perform comprehensive anatomical segmentation on the same workstations they already use.

pythoncythonnumpy+2
Student: Madhan Kumar R
Code

Gambit Interoperability with SageMath

intermediate
Gambit: The package for computation in game theory•2026Varies175h (Medium)

This project aims to enable SageMath to natively use Gambit’s functionality within its game-theory features, allowing seamless conversion between SageMath and Gambit Game objects and the application of each library’s tools to the other’s representations. A draft SageMath pull request already exists that handles packaging and import updates for pygambit, but the core task of updating SageMath’s game theory code to Gambit’s revised 16.6 API remains open. This project will complete and merge that PR, then produce tutorial and documentation materials that demonstrate what the integration enables and how to leverage it.

pythonc++wxwidgets+1
Student: Amelie Kleber
Code
Proposal

Enable float80/float128 on Unsupported Targets for LLVM libc

intermediate
LLVM Compiler Infrastructure•2026$3k–$6.6k175h (Medium)

This proposal is based on the LLVM project for GSoC 2026 with the same title, from Tue Ly, Nicolas Celik and Krishna Pandey. Discourse: https://discourse.llvm.org/t/gsoc-2026-libc-enable-float80-and-float128-math-support-on-unsupported-targets-for-llvm-libc/89647. Float80 (x87 80-bit extended precision) and Float128 (IEEE 754 binary128 quad precision) are high-precision floating-point formats critical for correctly rounded math implementations. However, not all compilers or architectures support these types natively which prevents LLVM libc from building and testing its high-precision math routines on these platforms. The goal of this project is to implement software support for these types in LLVM libc in a compiler and architecture agnostic way. Deliverables: - Implement float80 and float128 in a compiler and architecture agnostic way. Implement generic basic arithmetic operations that work on all supported architectures. - Demonstrate compiling and passing tests on unsupported targets (float80 on Mac ARM64, float128 on MSVC).

cllvmc+++3
Student: Sukumar Sawant
Code

Improve Zulip’s Native Integrations and Features around Keyboard and Settings.

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

For my project with Zulip, I aim to improve its integration ecosystem and core user experience. My project focuses on two primary areas: (1) Secure & Automated Integrations and (2) UX & Accessibility .In alignment with this year’s GSoC focus on security, under integrations, I will strengthen webhook systems by implementing secure payload verification, enabling automated topic resolution for GitHub, improving event handling, and expanding support for external platforms .For UX & accessibility, I will improve keyboard navigation(specifically macOS dropdown support) and refine settings features, including more accurate unread message handling in narrowed views.

pythonjavascriptdjango+5
Student: Pritesh Shetty
Code
Proposal

Reference Database: A Ground-Truth Food Data Platform for Canada

advanced
Open Food Facts•2026Varies350h (Large)

The Reference Database project aims to build a high-quality, reliable food data platform to complement and enhance Open Food Facts (OFF) in Canada. While OFF is a valuable open dataset, it can contain incomplete or inconsistent information. This project addresses these challenges by collecting and structuring trusted food product data from Canadian sources such as brand websites, retailers, and public registries. The goal is to create a clean and consistent dataset that improves data quality and supports downstream processing. The database will enable data enrichment, validation, and advanced use cases such as nutritional analysis, product categorization, and machine learning applications. It will also support better alignment with international standards and improve the overall reliability of food data. The project focuses on building a scalable data pipeline for data collection, cleaning, and integration, with the goal of delivering a functional MVP during Summer 2026.

androidmachine learningmongodb+6
Student: sara nour
Code

CauST: Causal Gene Intervention for Robust Spatial Domain Identification

advanced
UC OSPO•2026Varies350h (Large)

Spatial transcriptomics methods identify tissue domains by clustering spatial gene expression patterns, but current approaches select genes using variance-based heuristics such as highly variable genes (HVGs). Many HVGs reflect donor-specific noise rather than genes that truly drive spatial organization, which leads to poor generalization when models are applied across tissue slices from different donors. This project addresses this limitation by introducing CauST, a framework for identifying causally important genes for spatial domain identification. CauST evaluates each gene through in-silico gene knockout experiments, measuring how much removing the gene changes the learned spatial embedding produced by a spatial graph neural network. To ensure robustness, the method then applies a cross-slice invariance criterion, selecting genes whose effects are both strong and stable across multiple donors. The resulting causally invariant gene set is used to retrain spatial domain identification models, enabling improved cross-donor performance without modifying the underlying model architecture. The project will deliver a production-quality open-source CauST Python package, integration with multiple spatial transcriptomics backbones (STAGATE, GraphST, and SpaGCN), a multi-dataset benchmark evaluating cross-slice robustness, visualization tools for interpreting causal gene importance, and tutorial notebooks and documentation to support adoption by the spatial transcriptomics community.

pythonc/c++visualization+5
Student: Phil_Li
Code
Showing 337 - 360 of 13453 Projects
1314151617
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal