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

Scalable OCSMesh: Parallelization and Spatial Partitioning

advanced
IOOS•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 transform OCSMesh into a truly HPC-native tool by migrating its parallel architecture to mpi4py for distributed computing. Furthermore, I will implement a robust spatial partitioning engine that utilizes "windowed" data reading. This will decouple the meshing performance from the physical file structure, allowing OCSMesh to process global-scale datasets across supercomputing clusters without memory bottlenecks.

pythonocean sciencejava+3
Student: Anas Ibrahem
Code
Proposal

HTTP Streaming

intermediate
Ruby•2026Varies175h (Medium)

This project addresses the absence of HTTP streaming support in the Rage framework, where responses are currently fully buffered before being sent to the client. This limitation prevents real-time use cases such as incremental LLM outputs, live data feeds, and large streaming responses. Even when applications generate data in chunks, the Iodine server collects all output into a buffer and sends it only after completion, making true streaming impossible. To solve this, the project introduces native HTTP streaming using chunked transfer encoding across both Iodine (C layer) and Rage (Ruby layer). A new streaming path will be added to Iodine to support incremental writes with a robust backpressure mechanism, ensuring the event loop remains non-blocking. On the Rage side, a developer-friendly API (render stream:) will be implemented using enumerators and fibers, allowing applications to stream data declaratively while seamlessly handling pause/resume behaviour under backpressure. The deliverables include implementing the http_stream transport, a Rack-compatible streaming writer with lifecycle and backpressure management, and the Rage streaming API. The project will also provide integration tests, edge-case handling (e.g., disconnects, high load), and updated documentation. This enables real-time streaming in Rage while preserving compatibility and supporting future extensions like HTTP/2.

rubycjava+3
Student: Piyush-Goenka
Code
Proposal

Extending Rule-Based Symbolic Integration

advanced
SymPy•2026Varies350h (Large)

Symbolic integration is one of the central capabilities of any advanced calculator system e.g. Mathematica. SymPy currently provides several integration strategies including heuristic methods, algorithmic approaches such as the Risch algorithm, and a rule-based integrator implemented in sympy.integrals.manualintegrate. The manualintegrate module performs integration by recursively applying pattern-based rules similar to how integrals are solved manually. While this approach produces readable step-by-step results and supports a wide range of expressions, its current rule coverage is limited and many integrals involving special functions or structured products are not recognized. The goal of this project is to extend the rule-based integration system in manualintegrate, focusing on improving support for special functions, structured products, and rule prioritization. The project will expand the set of integration rules, improve heuristics for rule selection, and ensure better compatibility with SymPy's symbolic simplification system. The approach is to first analyze the gaps between manualintegrate and more comprehensive rule-based systems such as RUBI in order to identify missing classes of integrals and structural weaknesses. Based on this analysis, the project will design SymPy-compatible rule representations using its existing pattern-matching framework, ensuring consistency with the current architecture. New rules will then be implemented incrementally, with each addition accompanied by rigorous testing and validation to guarantee correctness and stability. Throughout this process, particular attention will be given to preserving and extending SymPy’s step-by-step explanation capability, ensuring that all newly supported integrals remain interpretable and aligned with human-style symbolic reasoning. The end goal is to make SymPy’s integrator more complete, explainable, and closer to human-style symbolic reasoning, while maintaining correctness.

pythonc++numpy+1
Student: SalahDin Rezk
Code
Proposal

Consolidate and advance the GPU infrastructure in Clad

intermediate
CERN-HSF•2026Varies175h (Medium)

Automatic Differentiation(AD) is a set of techniques to evaluate the derivative of functions specified by a computer program. Clad is a Clang-based automatic differentiation tool that transforms C++ source code to compute derivatives. Clad have demonstrated promising support for GPU-based differentiation through prior efforts involving CUDA, Thrust, and integrations with applications such as XSBench and LULESH. However, all this works remains fragmented and inconsistently tested. This project aims to consolidate the fragmented work and advance Clad’s GPU infrastructure into a robust and consistent system.

pythonc/c++machine learning+6
Student: Vedant Goyal
Code
Proposal

BOA Constrictor: Benchmarking Neural Backbones for HEP Data Compression

advanced
CERN-HSF•2026Varies350h (Large)

The LHC at CERN generates 30 petabytes of physics data every year. Current compression tools like LZMA treat this data like any other file and miss the statistical patterns unique to particle physics. The BOA Constrictor solves this by training a neural network to predict the next byte more accurately inside an entropy coder. The original BOA paper proved the concept works (4.03x compression on CMS data vs LZMA's 3.22x), but two gaps remain: Mamba doesn't install on Python 3.12, and nobody has compared alternative architectures under fair conditions. This project will build a benchmark suite comparing GRU, LSTM, MinGRU, Transformer, and Mamba under parameter-matched conditions. It will then optimize the best backbone using INT8 quantisation, pruning, and distillation, producing Pareto frontier plots showing compression ratio vs model size. Finally, it will explore physics-informed priors as an auxiliary loss to improve predictions. All code and results will be contributed back to the upstream BOA repository.

pythonc/c++machine learning+6
Student: Akarsh_sahlot
Code

Modernizing rs_loader: Migrating to Latest rustc Internals with HIR-based Extraction

intermediate
MetaCall•2026Varies175h (Medium)

This project aims to modernize MetaCall's rs_loader by migrating it to the latest rustc compiler internals. The current implementation relies on outdated APIs, making it incompatible with newer Rust versions. The project will focus on updating compiler integration, replacing AST-based traversal with HIR-based extraction, and adapting to changes in rustc_driver and related components. The approach includes analyzing breaking changes, incrementally migrating core modules (lib.rs, middle.rs, ast.rs), and ensuring compatibility with modern Rust toolchains. Deliverables include a fully working rs_loader compatible with the latest rustc version, improved type and function extraction using HIR, and updated documentation for maintainability.

pythonjavascriptc/c+++6
Student: Satvik Upadhyaya
Code

istSOS Role-Based Web Administration

intermediate
OSGeo (Open Source Geospatial Foundation)•2026Varies175h (Medium)

This project adds proper role-based access control to istSOS4 by making the web administration interface reflect the permissions already enforced in PostgreSQL through Row-Level Security (RLS). Right now, the backend enforces access correctly, but the UI does not — every user sees the same controls. This project fixes that. Each role (administrator, editor, viewer, sensor) will only see the pages and actions they are allowed to use. It also simplifies user and policy management by removing the current two-step workflow. Creating or updating a user will automatically apply the appropriate policies, reducing configuration mistakes and making the system easier to operate. To support real deployments, the project adds basic observability and debugging tools. A permission matrix shows what each role can do, and audit logs record access-related events. In addition, small utilities like permission explanation, access simulation, and change impact preview help admins understand and verify changes before applying them. The project also explores integration with external authentication providers (OIDC) so istSOS4 can work with single sign-on setups, including Grafana, without changing how permissions are enforced. Overall, the focus is to make permissions visible, predictable, and manageable for administrators.

pythonjavascriptc/c+++4
Student: Kinshuk Sanand
Code
Proposal

Enhancing a FHIR Resource Tabular Viewer for Efficient Data Exploration

advanced
Data for the Common Good•2026Varies350h (Large)

FHIR resources are powerful but difficult to explore in practice because their data is deeply nested, inconsistent across resource types, and hard to analyze in raw JSON form. This project will enhance the existing FHIR Resource Tabular Viewer to make healthcare data easier to search, filter, and interpret for researchers, clinicians, and developers. I will improve the transformation layer that maps nested FHIR structures into stable, readable table columns, strengthen exploration features (global search, column filters, sorting, column visibility, and row-level drill-down), and extend ingestion support to additional sources, specifically local files and Amazon S3. Key deliverables are: (1) an improved and more reliable FHIR-to-table transformation pipeline for common resource types (2) upgraded table exploration and visualization workflows (3) modular data-source support for local and S3-backed datasets (4) performance improvements for larger datasets (5) expanded automated tests and documentation. The final outcome will be a more scalable, maintainable, and user-friendly viewer for real-world FHIR data exploration.

pythonjavascriptkubernetes+2
Student: O-Abdelaziz
Code

Virtual Filesystem for Molecular Dynamics Dataset Metadata in Apache Airavata

advanced
Apache Software Foundation•2026Varies350h (Large)

This project builds a FUSE-based virtual filesystem in Rust that exposes molecular dynamics dataset metadata as a POSIX-compatible interface for scientific workflows on HPC environments. Starting with the ATLAS dataset (1,900+ proteins), the filesystem mounts dataset metadata as a browsable directory tree where each protein entry is a directory containing its metadata as JSON files, accessible through standard filesystem operations (ls, cat, find). The architecture uses pluggable data source abstractions so additional molecular dynamics databases (mdCATH, MemProtMD) can be unified behind the same filesystem API with per-source connectors. An existing Python indexing layer crawls and normalizes heterogeneous source formats (TSV, HDF5, REST APIs) into a uniform POSIX tree structure that the Rust FUSE daemon serves. Performance is benchmarked against direct API access for metadata retrieval latency.

pythonjavascriptjava+7
Student: Jayanth Vennamreddy
Code

Use LLVM libc math routines for compiler-rt floating point routines

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

compiler-rt builtins provide software floating-point routines (__addtf3, __multf3, __floatsitf, etc.) for targets that lack hardware FP support. The current implementations carry two problems. First, they are under-tested, and subtle bugs survive for years. PR#119449 shows one example: __floatdixf relies on the compiler to lower a cast, but the compiler implements that cast by calling __floatdixf, creating infinite recursion. Second, the codebase mixes C and hand-written assembly across architectures, which makes maintenance and extension to new types (_Float16, bfloat16) expensive. LLVM libc implements these same operations using formally verified building blocks (FPBits<T>, DyadicFloat<N>, BigInt<N>) with exhaustive test coverage. A recent refactoring effort (#147386) made these routines available as free-standing, header-only C++ utilities. This project replaces the legacy compiler-rt FP builtins with thin C++ wrappers that call into LLVM libc's verified routines, gated behind a CMake flag so the change is transparent and non-disruptive.

cllvmc+++3
Student: Mohamed Emad
Code

Reproducible Builds: Pipeline Wiring, Verification Tooling, and Benchmark Suite

advanced
Konflux•2026Varies350h (Large)

Konflux container builds produce different image digests from identical source commits. The buildah task already supports reproducibility flags, but the pipelines don't wire them and there's no way to verify reproducibility automatically. This project audits all non-determinism sources in the build pipeline, wires SOURCE_DATE_EPOCH and related parameters through every pipeline variant, builds a benchmark suite of Containerfiles that exercise different reproducibility scenarios, and creates a standalone verify-reproducibility Tekton task. Deliverables: a non-determinism audit document, pipeline wiring patches, a 5+ Containerfile benchmark suite, a verification task with diffoci integration, and user/developer documentation.

pythongodocker+2
Student: Jamesss
Code
Proposal

Implementing GPU Multi-Stream Capabilities to Dagger.jl

intermediate
The Julia Language•2026Varies175h (Medium)

Dagger.jl currently serializes all GPU tasks onto a single stream per device, leaving independent DAG branches unable to run concurrently and GPU hardware severely underutilized. This project implements multi-stream execution for the CUDA and ROCm backends by replacing the single fixed stream with a per-device stream pool, integrating stream-aware scheduling into the task dispatch layer, and replacing the global device barrier with event-based synchronization. The expected outcome is a significant reduction in end-to-end latency, improved Streaming Multiprocessor occupancy, and meaningful overlap between memory transfers and kernel execution.

cjavascriptc+++12
Student: Victor Camara
Code
Proposal

ActiveVision: continued development of a data and model portal for the study of goal-directed vision

advanced
INCF•2026Varies350h (Large)

This project builds an automated benchmarking ecosystem for goal-directed vision. It implements a high-priority leaderboard featuring automatic updates, submission validation, and multi-metric ranking for new Diffusion and VLM paradigms. It ensures reproducibility through versioned results for SOTA research.

pythonjavac+++7
Student: Lihong Chen
Code
Proposal

Streamlining Pharo’s Refactoring Engine UI/UX

intermediate
Pharo Consortium•2026Varies175h (Medium)

Pharo provides an immersive and interactive development environment with powerful refactoring tools. However, its current refactoring workflows can be fragmented, rely on frequent pop-ups, and offer limited feedback, making them less user-friendly. This project aims to improve the usability and interactivity of Pharo’s refactoring tools, with a focus on rename operations. To achieve this, the project will develop a flexible driver and preview infrastructure that supports safe experimentation, introduce live name editing with immediate validation, and enhance the visualization of changes through a hierarchical tree structure. The expected outcomes include a streamlined refactoring workflow, a clear hierarchical preview of all changes, real-time validation of user input, and a more intuitive and interactive user experience that helps developers better understand and manage code transformations.

smalltalkroassalpolymath+7
Student: Biljana
Code
Proposal

pgmoneta: Storage engines

intermediate
PostgreSQL•2026Varies175h (Medium)

pgmoneta’s current storage layer is fragmented, back-ends do not share full feature parity and a single backup cannot target multiple destinations at once. This project introduces a unified storage interface that every backend implements, enabling easier maintenance and concurrent multi-backend writes. SSH and Azure backends are raised to the same capabilities as S3, while new native drivers for Google Cloud Storage (GCS) and SMB are added. Robustness is ensured by extending the MCTF framework with empirical infrastructure tests for each backend.

cpostgresqlperl+8
Student: Shashidhar M
Code
Proposal

Enhance OpenACC Support in GCC

intermediate
GNU Compiler Collection (GCC)•2026Varies175h (Medium)

GCC currently supports most OpenACC directives for GPU offloading, but several features remain unimplemented or incomplete. This project targets four concrete gaps in the OpenACC implementation within GCC: - init, shutdown, and set directives (OpenACC 2.5+): Implementing the directive-form equivalents of the already-available runtime API routines, following the pattern of the existing #pragma acc wait infrastructure. - bind clause: Extending full support to C, C++, and Fortran by mapping the clause to OpenMP declare target and declare variant directives at the middle-end level or implementing OpenACC specific code. - device_type clause: Filtering clauses in the GIMPLE IR linked list based on the target device type at compile time using the ACCEL_COMPILER variable. - cache directive: Moving beyond the current no-op behavior by emitting prefetch instructions and/or placing data in low-latency memory using existing GCC prefetch infrastructure and OpenMP memory traits for certain use cases. Additionally, once core tasks are complete, the project will survey newer OpenACC specification features, producing a structured list of unimplemented functionality with prioritized implementations and documentation to ease future contributions. Deliverables include upstream patches for each directive/clause with test suite additions for C, C++, and Fortran, and documentation updates to the relevant documentation files.

cc++openmp+3
Student: Sebastian Galindo
Code
Proposal

Revamping the GIMP Text Engine HarfBuzz and OpenType

intermediate
GNU Image Manipulation Program•2026Varies175h (Medium)

GIMPs typographic engine is currently limited by legacy GTK3 and Pango constraints. This project overhauls the text backend by directly integrating HarfBuzz to extract font data and advancing GIMPs experimental text layout library. Deliverables include migrating the font chooser to modern GTK list models, grouping fonts by WWS families, and introducing modular on canvas UI controls for variable font axes and OpenType features.

cGEGL
Student: v4vansh
Code
Proposal

Pairwise Causal Discovery Algorithms in pgmpy

beginner
German Center for Open Source AI•2026Varies90h (Small)

This project adds pairwise causal discovery methods to pgmpy, focusing on inferring causal direction between two variables from observational data. It includes implementations of ANM, IGCI, and Bivariate LiNGAM under a simple, unified interface, along with an HSIC-based independence test and basic benchmarking using the Tübingen CauseEffectPairs.

pythonpytorchscikit-learn
Student: aryaman.iiit
Code
Proposal

Improve handling of older documents by OCR and AI

advanced
JabRef e.V.•2026Varies350h (Large)

JabRef, comprehensive literature management software, currently supports both handling metadata and text-based PDF documents. However, a significant limitation arises with scanned PDFs, particularly historical articles, which are not text-searchable due to their image-based format. This project aims to bridge this gap by integrating advanced OCR (Optical Character Recognition) technology, enabling full-text search in scanned PDFs.

javajavafxlatex+3
Student: Zeyad Abdelfattah
Code
Proposal

Support for Java 17 in jpf-core

intermediate
The JPF team•2026Varies175h (Medium)

JPF currently cannot fully analyze Java 17 programs that use sealed classes and records — two features now standard in modern Java. This project completes Java 17 support in jpf-core by fixing sealed class enforcement, adding full record support (classfile parsing, metadata storage, and execution), and producing a Java 17 audit document that maps all remaining gaps for future contributors. The work targets the java-17 branch and builds on an existing contribution to the codebase.

androidjavadistributed systems+2
Student: Darshan Raghavendrachari
Code
Proposal

Per-Session GDB Sandbox Architecture with Real-Time Debugging for GDB-UI

intermediate
C2SI•2026Varies175h (Medium)

GDB-UI currently supports only one user at a time because the backend shares a single global GDB controller across all requests. When two users debug simultaneously, the second session silently destroys the first with no error or warning. This proposal implements a three-phase solution. Phase 1 replaces the global controller with a thread-safe SessionManager that gives each user their own isolated GDB instance via a UUID session_id. A working implementation is already open as PR #131 with 15 passing tests, security fixes, and a live demo page. Phase 2 introduces WebSocket streaming with a per-session reader thread architecture so GDB output reaches the frontend in real time without blocking the server. Phase 3 moves each project into an isolated Docker container using the Docker SDK exec_start socket API for interactive GDB attachment, solving file descriptor exhaustion at the OS level. Deliverables: merged SessionManager with full test coverage, WebSocket streaming with reconnection handling, Docker sandbox with resource limits, security audit, and handover documentation.

pythonjavago+2
Student: Udaybir Singh
Code
Proposal

Wikifile Transfer Enhancement

intermediate
Wikimedia Foundation•2026Varies175h (Medium)

The current Wikifile Transfer tool is constrained as a single-transfer utility. This creates highly repetitive manual work for contributors migrating non free media across sister projects, lacks durable upload history for failure diagnosis, and misses automated category localization. This project evolves the tool into a robust, job based batch transfer pipeline using Python, Flask, Celery, and React. The solution implements a durable MySQL state machine to track transfer lifecycles and ensure fault tolerance. Key deliverables include: 1) A batch upload API and React UI orchestrator, 2) A persistent History Dashboard with safe, targeted retry logic for failed jobs, 3) Automated, non destructive category localization using MediaWiki APIs, and 4) Comprehensive E2E and backend testing using Cypress and Pytest. This enhancement will eliminate manual bottlenecks and save thousands of volunteer hours across Indic language communities.

javascripthtmlphp+7
Student: Anirudh Bharatiya
Code
Proposal

Debusine: live log streaming

intermediate
Debian•2026Varies175h (Medium)

Debusine currently only shows task logs after a task has fully completed. This means developers working with long-running jobs (such as package builds or test pipelines) have no way to monitor progress in real time or catch failures early. This project adds live log streaming to Debusine. The implementation follows a four-stage pipeline. On the worker side, the sub-process runner will be extended to capture stdout and stderr incrementally as a task runs, sending each line to the server over the existing WebSocket connection rather than waiting for the task to finish. On the server side, a handler will receive these lines and write them to a per-task Redis Stream, providing a persistent, ordered, low-latency buffer that supports multiple simultaneous readers. A server-side view will then expose these log lines to browser clients via Server-Sent Events or a WebSocket endpoint. As a stretch goal, the Debusine web UI will subscribe to that endpoint and display lines appearing on the task page in real time, with no page refresh required. Deliverables: - Worker-side incremental log capture and WebSocket emission, with full test coverage - Server-side Redis Stream ingestion, per-task key namespacing, and post-task flush to PostgreSQL - A server view that streams log lines to browser clients for running tasks - A browser-side UI update that shows live output on the task detail page using plain JavaScript, without any frontend framework

pythonjavascriptc/c+++8
Student: mo-ashraf
Code
Proposal

SeaSee’r: Immersive ROV Mapping

advanced
International Catrobat Association•2026Varies350h (Large)

This project develops an open-source system to visualize and explore complex data from underwater ROVs, integrating panoramas, sonar, and point clouds into a Google Street View–like interface. It enables advanced tasks like mission planning, site re-identification, and live data registration, while supporting evolving scientific goals, new data modalities, and multiple vehicle types for long-term underwater research.

javascriptandroidswift+4
Student: Cott3r
Code
Proposal
Showing 553 - 576 of 11996 Projects
2223242526
Proposal
Proposal
Proposal
Proposal
Proposal