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

Enhance Pedestrian Routing

advanced
OpenStreetMap•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)

The majority of mapped sidewalks in OSM lack explicit names, which makes Valhalla generate vague pedestrian routing instructions. This project aims to resolve this problem with three different steps: First, parsing existing OSM tags such as (is_sidepath:of:name, street:name) that are currently ignored, as name aliases. This is a low-risk change that immediately benefits around 30,000 ways worldwide. Then, implementing spatial join in the graph enhancer that assigns street names to unnamed sidewalks by comparing them to nearby vehicular edges with matching heading parallelism and geometric proximity, using angle and distance thresholds. Third will be adjusting Odin's narrative generation so derived names produce natural phrasing instead of the current vague ones. Deliverables include Lua tag parsing with gurka integration tests, the spatial join algorithm with edge case handling, modified maneuver instructions, and performance benchmarks measuring tile build impact. Nice-to-have goals include using (is_sidepath:of) to adjust road class in the Sif pedestrian costing, detecting park entrances and the new ideas we discover during the project.

javascriptjavaopengl+10
Student: pacoalbacetec
Code
Proposal

Hierarchical Collectives for HPX

advanced
Ste||ar group•2026Varies350h (Large)

HPX's existing hierarchical communicator (PR #6834) implements four one-to-all collectives (broadcast, reduce, scatter, gather) with a configurable k-ary tree structure. This project will implement the remaining all-to-all collectives: all_reduce, all_gather, and all_to_all ,using the existing hierarchical communicator, produce rigorous three-way benchmarks (hierarchical HPX vs. flat HPX vs. tuned MPI), and prepare the implementation for integration into an upcoming HPX release.

c++cudaopencl+10
Student: Anshuman Agrawal
Code
Proposal

Integrating FLINT/Calcium Algebraic Number Fields as a Backend for SageMath's AA and QQbar.

advanced
SageMath•2026Varies350h (Large)

Problem: SageMath's algebraic number fields (AA/QQbar) have performance bottlenecks in equality testing, arithmetic on high-degree numbers, and symbolic conversion—limitations that affect users in number theory and algebraic geometry. Solution: Integrate FLINT's qqbar_t (Calcium module) as an optional high-performance backend. FLINT is already a Sage dependency, and Calcium provides optimized algebraic number algorithms with rigorous numerical enclosures. Approach: >Create Cython bindings for qqbar_t in sage/libs/flint/ >Implement AlgebraicNumber_flint element and AlgebraicField_flint parent classes in sage/rings/qqbar_flint.py >Ensure coercion compatibility with existing AA/QQbar >Deliver tests, benchmarks, and documentation Deliverables: >Complete Cython bindings for core qqbar_t operations >Drop-in replacement classes for AA and QQbar with full arithmetic and coercion >Test suite and performance benchmarks >User and developer documentation The new backend will be optional initially, enabling side-by-side comparison, with the potential to become the default after validation. This will make algebraic number computations in Sage faster and more robust.

pythoncython
Student: Madhu Sripada
Code
Proposal

Reviving and modernising Robotic Workbench

beginner
FreeCAD•2026Varies90h (Small)

FreeCAD comes with a Robot Workbench, which is capable of 6-DOF robot simulations, trajectory planning and a vendor specific code export (KUKA). After the removal of some copyrighted model assets and years without an active maintainer, the workbench is functional but difficult to use and customise. The robots can only be defined via hand-written VRML and CSV/DH files, the bundled kinematics library has lagged behind the latest upstream release, the axis count for robots is hard coded to six and the documentation for beginners is sparse. Thus this project proposes an incremental modernization of the existing “Mod/Robot” module: 1. Standardised robot imports : Unified Robot Description Format (URDF) is one of the most common standards for describing a robot. Having an easy way to import robots directly from URDF will replace the painful CSV/DH file imports. 2. Generic joint-trajectory export : Having the possibility to export the joint & trajectory data will separate the export process from copyrighted vendor-specific pipelines. The users can post-process the exported data to their specific platform 3. Kinematics library refresh : FreeCAD currently has a local fork of KDL library that lags behind the upstream. Cleaning up this dependency will eventually prepare the path for arbitrary-DOF robots & better robot animations. 4. Documentation : This will help the existing users as well as attract a new user base towards the Robotics Workbench.

pythonc++qt+2
Student: nishendra
Code
Proposal

[Mogan STEM] Web-Based Collaborative Editing Core

advanced
MoganLab•2026Varies350h (Large)

This project focuses on transforming Mogan STEM into a web-based, multi-user collaborative platform. Currently, the lack of a functional WebAssembly (WASM) version and real-time synchronization limits its use in modern collaborative research. To solve this, I will compile Mogan STEM using Emscripten, implementing a custom virtual file system to ensure stability. Furthermore, I will develop a real-time collaboration core based on Operational Transformation (OT) and WebSockets. This architecture allows multiple users to edit complex scientific documents simultaneously with "local-first" responsiveness and guaranteed global consistency. Deliverables include: 1. A stable browser-based version of Mogan STEM. 2. An OT-based synchronization server. 3. A complete end-to-end prototype supporting real-time multi-user collaborative editing.

c++qtscheme
Student: JimZhou
Code
Proposal

Improving the Usability of the 4diac IDE's State Machine (ECC) Editor

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

The ECC State Machine Editor in 4diac-IDE has not received the usability improvements applied to other editors like the FB Network Editor. Engineers face friction points: incorrect state placement at zoom levels, strange spline trajectories in transition routing, unreliable Ctrl-drag transition creation, and missing error feedback for invalid conditions. This project takes a three-phase approach: (1) systematic usability analysis and codebase foundation cleanup, (2) fixing identified bugs, and (3) enhancements including Canvas Direct Edit for transition conditions, Smart Snapping, and ECC Live State Highlighting during debugging. Deliverables: Usability Analysis Document, bug fixes (spline trajectory, Ctrl-drag, error feedback, marker navigation), 6+ enhancements, all submitted as focused PRs with documentation and a final project report. Pre-GSoC work already completed: 6 PRs merged including zoom coordinate fix, CreateTransitionCommand cleanup, and documentation improvements — all under direct guidance of mentor Alois Zoitl.

c/c++javageospatial+15
Student: Vikash Kumar Sinha
Code

Machine Learning for Gravitational Lens Finding

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

Strong gravitational lenses are rare and scientifically valuable, but finding them in large imaging surveys requires automated methods. Furthermore, simulated data is used due to the lack of available data, but models trained on simulated lensing images suffer a significant performance drop when applied to real observations (the sim-to-real domain gap). This project addresses that gap by combining equivariant neural networks (ENNs), which exploit the rotational and reflectional symmetries of lensing images, with domain adaptation techniques to build a lens-finding pipeline that transfers reliably from simulated training data to real survey images. The project will also develop a hybrid adaptation strategy that chains unsupervised alignment with supervised contaminant rejection to reduce false positives from visually similar objects like spiral galaxies. Through this project, I aim to build a benchmarked ENN+DA pipeline integrated into the DeepLense codebase, a ranked list of lens candidates from an HSC-SSP subregion with catalog cross-matching and property analysis, a cross-survey generalization evaluation, and a final research report with blog post.

pythonmachine learningc+++2
Student: MichaelJiao
Code

Adding native Fortran support in LLDB

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

As the LLVM Flang frontend matures, a significant gap has emerged between compilation and diagnostic capabilities. Currently, LLDB does not provide native debugging support for Fortran. This project aims to address that gap by building the essential foundation for native Fortran debugging. The goal is to deliver a functional debugging stack that allows users to: Inspect Variables: Support for scalar variables, function arguments, and return values. Data Structures: Inspection of static arrays, character strings, and derived types. Visibility: Implementation of module and global variable lookups. Expression Evaluation: Enabling basic arithmetic and variable inspection via the print command. To achieve this, a new Fortran TypeSystem, a dedicated Language Plugin, and a DWARFASTParser to interpret and traverse Fortran-specific DWARF metadata are needed.

cllvmc+++3
Student: Iason Karaprodromidis
Code
Proposal

OpenROAD-MCP Docker Deployment and Cross-Platform Support with Production-Ready Testing and QA

advanced
The OpenROAD Initiative•2026Varies350h (Large)

OpenROAD-MCP's adoption is limited by manual setup and the lack of production-grade deployment and validation workflows. This project delivers a complete Docker deployment story with GHCR publishing, cross-platform validation across Ubuntu, macOS, and WSL2, and a six-layer testing infrastructure covering integration tests against real ORFS flows, performance benchmarking, load testing, and memory profiling thus moving the project toward a reliable v1.0 release.

pythonverilogc+++2
Student: KartikMittal
Code
Proposal

Contribute to LORIS: Improving reliability and maintainability in the electrophysiology browser

intermediate
INCF•2026Varies175h (Medium)

This project aims to improve the reliability and maintainability of the LORIS electrophysiology browser through scoped enhancements to browser behavior, validation, testing, and documentation. I plan to begin by reviewing and reproducing known issues or limitations, then implement targeted improvements in small, reviewable stages with mentor feedback. The expected deliverables include a practical browser improvement, expanded automated test coverage, and developer-facing documentation that helps make the contribution sustainable within the LORIS codebase.

pythonjavac+++7
Student: Montek
Code
Proposal

Restoring Typeclass Refinement Support in LiquidHaskell

intermediate
Haskell.org•2026Varies175h (Medium)

LiquidHaskell is a verification tool that allows Haskell developers to prove the correctness of their code through refinement types. This proposal aims to restore the support for type class elaboration: a feature that enables the verification of typeclasses laws and instances. The work that had been done previously to support typeclass elaboration is currently broken: typeclass methods produce "Unknown logic name" errors, hence the test suite for the feature has been disabled. The aim of this project is to restore this functionality, by fixing the elaboration mechanism responsible for making typeclass methods available during verification. I will trace the elaboration pipeline, implement the necessary fixes and extend test coverage. Additionally, the project will include an in-depth analysis of the features supported by the implementation and how they compare against the expected outcomes in the original paper. The deliverables will include successfully merged contributions on the LiquidHaskell GitHub repository, with its corresponding documentation, and a post with the solution on the Tweag blog.

haskellghccabal+3
Student: Juan Pablo Yamamoto
Code
Proposal

Building a Perturbation-Aware LLM for Multimodal In Silico Perturbation Modelling

intermediate
Genome Assembly and Annotation•2026Varies175h (Medium)

Perturbation biology datasets across CRISPR screens, MAVE, and scPerturb-seq remain siloed in incompatible formats, making cross-modal reasoning about genetic perturbations nearly impossible at scale. This project builds a perturbation-aware LLM by fine-tuning BioMedLM on a curated multimodal training corpus derived from the EMBL-EBI Perturbation Catalogue, enabling natural language queries such as "what happens if gene X is knocked out in cell type Y?" Deliverables include a multimodal training corpus, a fine-tuned LLM prototype, a reproducible evaluation pipeline with gene-level splits distinguishing genuine generalisation from memorisation, and full open-source documentation for reuse by the Perturbation Catalogue team.

pythonmysqljavascript+4
Student: Esra Ersan
Code

Pin projects to the Android launcher (“Play as app” shortcuts)

intermediate
International Catrobat Association•2026Varies175h (Medium)

Currently, Catrobat users have to return to the Catroid IDE every time they want to play their projects, which breaks the experience and makes their creations feel less like real, standalone apps. To address this, I propose introducing a “Pin to Home Screen” feature that allows users to launch their projects directly from the Android home screen, just like any other app. This will be achieved using a lightweight ShortcutTrampolineActivity that retrieves the project ID and opens it directly in Play mode, along with proper task configuration so each project runs independently and exits back to the home screen instead of the IDE. The project will include a smooth UI integration with adaptive icons, a decoupled StageActivity for independent execution, robust lifecycle handling to manage renamed or deleted projects safely, and comprehensive automated testing (JUnit and Espresso) to ensure reliability across different Android versions.

javascriptandroidswift+4
Student: Harsh somankar
Code

Scaling translation operations in wagtail-localize

advanced
Wagtail•2026Varies350h (Large)

This project focuses on improving the performance of core processes in wagtail-localize, particularly in the construction of the page index and in translation workflows that operate on large page trees. Current analysis of the codebase reveals patterns that lead to repeated database queries and sequential processing, which can negatively impact performance as the number of pages and locales grow. These issues become especially noticeable in large, content-heavy sites, where administrative actions such as translating or updating page subtrees can become slow and less reliable. The project will begin by measuring query counts and execution time for key operations, establishing a baseline for comparison. Based on these measurements, the page index construction will be refactored to reduce database queries by fetching data more efficiently and processing it in memory. Translation workflows will be analyzed to identify opportunities to reduce sequential processing and improve performance when processing large page trees. Additionally, the current mechanism for detecting content changes will be reviewed to reduce unnecessary work when no updates are required. The main deliverables include characterization tests and benchmarks, a refactored page index implementation with reduced query counts, improvements to translation workflows, and an evaluation and potential optimization of content change detection. All improvements will be validated against the established baseline to ensure measurable performance gains.

pythonjavascriptdjango
Student: Rodrigo Yanez Pilgrim
Code
Proposal

Parallelizing loo

intermediate
NumFOCUS•2026Varies175h (Medium)

The `loo` package is a widely used R package in the Stan ecosystem which exposes a clean API to cross-validate (CV) Bayesian models. Currently, some `loo` functions use parallelization by way of forking processes, which doesn't work on Windows but has some benefits over other parallelization schemes with respect to memory. The `mirai` package is a new approach to cross-platform parallelization which relies on daemons, allowing package developers to write parallel code without any knowledge of where the code will be executed--allowing users to scale up to any number of local or remote cores. `mirai` represents one approach to updating `loo`'s approach to parallelization. After this project, users of `loo` will be able to run some expensive calls in parallel, regardless of the OS they use, and ideally in any environment they would like--be it a SLURM cluster, SSH access to a large server, across a homelab, or just on many cores on their local machine.

pythonjavascriptr+3
Student: Visruth
Code
Proposal

Event Classification With Masked Transformer Autoencoders

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

The proposal titled "Event Classification With Masked Transformer Autoencoders" aims to enhance particle jet tagging by developing a Lorentz-equivariant Particle Transformer (Lorentz ParT) that adheres to the symmetries of special relativity. This hybrid architecture combines Lorentz Geometric Algebra Transformers (L-GATr) with Particle Transformers (ParT) to compute physical invariants, such as invariant mass, while tracking geometric orientations between particles. A key innovation is the introduction of Gated Particle Attention, which addresses residual bottlenecks in standard transformers by dynamically weighting contextual information against original features. The model is designed for a dual-head functionality, performing both self-supervised classification across ten unique jet classes and continuous mass regression using the JetClass dataset. To optimize learning, a Masked Autoencoder (MAE) approach is utilized to understand underlying jet symmetries before label-based training begins. Preliminary results indicate that the gated prototype can achieve a lower eta loss than original methodologies, although it currently faces challenges with "hallucinating noise" in reconstruction maps due to increased parameter counts. The proposed 12-week execution plan focuses on establishing mass regression, mitigating ROC curve issues, and validating the architecture against a scratch model to ensure stable performance

pythonmachine learningc+++2
Student: Avishikta Bhattacharjee.
Code

BRLCAD Python bindings

intermediate
BRL-CAD•2026Varies175h (Medium)

I plan to make BRL-CAD python bindings. Basically my goal is to make a Python interface for BRL-CAD using MOOSE as the core modeling backend, with a thin C bridge between Python and C++ for stability and portability. The architecture is: Python interface -> moose_rt3 adapter (ctypes) -> C bridge -> MOOSE C++ API -> BRL-CAD database engine -> .g file. I plan to work around 3 goals: 1. Database lifecycle behavior should be consistent across read-only, writable and in memory modes with clear errors when operations are invalid 2. Core primitives and CSG operations should be exported correctly and transforms must be stored as combination-member matrices so results are verifiable by MGED. 3. Unified read access: provide one Python read entrypoint for supported object families with a stable return format and desterministic errors for missing or unsupported objects

pythonc/c++opengl+6
Student: Waleed05
Code
Proposal

nicheR shiny: Interactive GUI for ellipsoid-based virtual niches

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

Virtual niche simulations are a powerful tool for testing ecological theory, and nicheR provides an integrated, R-native framework for ellipsoid-based virtual niche construction, prediction, and data generation. This project will deliver a Shiny graphical user interface for nicheR, making these tools accessible to researchers regardless of their programming background. The app will guide users through a complete virtual niche workflow across six tabs: data input, niche design, prediction, bias preparation, data sampling, and reproducibility. Throughout, contextual messages will explain the ecological meaning of key parameter choices, ensuring users understand the theory behind what they are building rather than just clicking through steps. A key feature is that every interactive session generates a fully reproducible R script, so users can transition seamlessly from the GUI to scripted workflows. Deliverables include a fully functional Shiny app packaged within nicheR with a run_app() launcher, test cases for each module, and two vignettes. By lowering the technical barriers to ellipsoid-based niche modeling, this project expands access to rigorous, theory-driven tools for ecologists, conservation practitioners, and students across the R community.

cc++r+4
Student: Mariana Castaneda Guzman
Code

Native SVG Import/Export for p5.js via p5.Shape System (custom Project)

intermediate
Processing Foundation•2026Varies175h (Medium)

This project aims to add native SVG import and export capabilities to p5.js through enhancements to the p5.Shape system. Currently, p5.js only supports raster exports which limits professional workflows for artists and educators who require vector outputs. The project will first extend the Shape system by adding ArcSegment and EllipseSegment primitives to enable structured geometry recording. Then an SVG export add-on will be developed using a visitor pattern to convert recorded primitives into clean SVG paths with transform support. Key deliverables include a shape recording API, SVG export via saveSVG(), basic SVG import support, documentation, and tests. This will improve interoperability of p5.js with design tools and vector workflows while maintaining backwards compatibility.

pythonjavascriptandroid+6
Student: vansh kabra
Code

MCP Server and Agent for CDLI

beginner
Cuneiform Digital Library Initiative (CDLI)•2026Varies90h (Small)

This project improves access to the CDLI database by enabling natural language queries instead of complex search forms and syntax. It allows researchers and students to explore the database more easily without needing detailed knowledge of its structure. The system consists of an MCP server that translates plain English queries into structured CDLI API calls, along with an AI-powered research workspace embedded on the CDLI website. Users can search, retrieve, and explore data through a simple chat interface, and generate structured research outputs. Key deliverables include a production-ready MCP server, an interactive research interface, a guided research paper generation workflow, and comprehensive documentation with testing support.

pythonmysqljava+8
Student: armaanngupta
Code
Proposal

OpenComet Nano-Satellite Mission Orbit Simulation Suite

Intermediate
Open Cosmos Space Missions•2026€2k–€4kStandard (~175h)

Develop a high-fidelity power budget and sun-pointing angle simulator for solar panel arrays in Low Earth Orbit (LEO).

rusttypescriptwebassembly
Aleix Megías Homar, Jordi Barrera
Code
Proposal

Modernizing LibTorch Backend with Zero Copy and Batching

advanced
FFmpeg•2026Varies350h (Large)

Building upon the recently merged asynchronous execution infrastructure in the FFmpeg LibTorch backend, this project targets two high-impact performance improvements: a production-grade zero-copy GPU pipeline and an optional batching engine for throughput scaling. The primary objective is to reduce host-device transfer overhead, improve real-time inference efficiency, and strengthen backend reliability for practical video processing workloads. The project deliverables include implementation, validation, and documentation aligned with FFmpeg quality and integration standards.

cgitasm+3
Student: Raja Rathour
Code
Proposal

Mailman 3 Domain Administration in Postorius

intermediate
GNU Mailman•2026Varies175h (Medium)

This project implements the domain owner role in Postorius. Right now, Mailman 3 has site admins, list owners, and list moderators, but domain administration is not fully complete. This project will allow domain owners to create mailing lists only in domains they own, use list-owner features for lists in those domains, and edit settings for their domains. The work involves updating Postorius auth helpers, reusing existing decorators and mixins, updating list creation and domain edit views, making UI changes, and adding tests. Expected result: working support for domain owners to manage lists and domains they own, along with proper test coverage.

pythondjangoemail+4
Student: a-khushal
Code
Proposal

Patient Visit Summary Printing for OpenMRS O3

intermediate
OpenMRS•2026Varies175h (Medium)

OpenMRS lacks a printable visit summary, forcing patients to verbally relay medical history during referrals and care transitions. This project adds a Visit Summary PDF generator to the existing openmrs-module-patientdocuments module, reusing the proven Patient ID Sticker pipeline (DataSetEvaluator, XML Renderer, Apache FOP). The backend gathers visit-scoped clinical data (vitals, diagnoses, lab results with reference ranges, allergies, medications, visit notes) via batch queries, renders it as XML, and transforms it to PDF through XSLT. An extensible VisitSummarySectionProvider SPI allows any module (billing, appointments, pharmacy) to contribute sections without modifying the core module. Configuration uses deploy-time Initializer keys for section toggles, concept UUIDs, and page sizes (A4/A5/A6). The frontend adds a print button in the O3 visit-detail-overview-actions slot with iframe-based PDF preview and download fallback. Deliverables include the complete backend pipeline with all clinical sections, extensible SPI architecture, configurable XSLT stylesheet, REST endpoint with privilege enforcement, frontend print extension, comprehensive tests, and documentation.

javahtml5groovy+11
Student: Amrita P.
Code
Proposal
Showing 457 - 480 of 13453 Projects
1819202122
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal