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

Metadata Tracking and Hyperparameter Visualization for Visdom

intermediate
FOSSASIA•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)

Currently, Visdom excels at real-time visualization but lacks persistent experiment tracking and historical run filtering. To solve this, this project introduces a lightweight, self-hosted experiment management layer built natively into Visdom using SQLite and SQLAlchemy. It adds a structured metadata store, a custom key-value query engine for filtering runs, an interactive Parallel Coordinates pane for hyperparameter visualization, and Optuna integration, bringing Visdom to parity with modern ML tracking tools.

pythonjavascriptandroid+7
Student: Zhengyang Peng
Code
Proposal

Parallel HNSW Index Construction for MariaDB Vector Search

advanced
MariaDB•2026Varies350h (Large)

MariaDB's HNSW vector index currently builds graphs sequentially, one row at a time. This creates two problems: ALTER TABLE on large tables stalls for hours because every vector insertion runs a CPU-intensive graph traversal on a single thread, and OPTIMIZE TABLE provides no quality improvement because it blindly rebuilds with the same hardcoded parameters, also leaving dead edges from deleted rows in the graph. This proposal addresses both by hooking into MariaDB's bulk insert API to defer all graph construction until after the base table is fully populated, then building the graph in parallel across multiple worker threads. Since OPTIMIZE TABLE already falls back to a table rebuild internally, both operations share the same unified path. The result is significantly faster index construction through parallelization, and meaningfully better graph quality through configurable rebuild parameters, with no changes to the normal single-row insert path.

cmysqlmariadb+7
Student: ahmdssh
Code
Proposal

improving RAIDframe

advanced
The NetBSD Foundation•2026Varies350h (Large)

RAIDFrame is NetBSD’s kernel-level software RAID framework, providing RAID 0, 1, 4, 5, and 6 functionality. Its current implementation has limitations: n-way RAID 1 is limited, RAID 6 performance can be improved, and the system lacks robust scrubbing support to detect and correct silent data corruption. This project will implement n-way RAID 1, RAID scrubbing, and RAID 6 improvements to enhance reliability, performance, and maintainability.

networkingkernelbsd+13
Student: Emmanuel Nyarko
Code
Proposal

A Frontend for Safe GPU Offloading in Rust

intermediate
The Rust Foundation•2026Varies175h (Medium)

The `offload` feature is currently working on the Rust compiler but still there's no safe and user-friendly interface. Right now, the only way to use it is via the `offload` intrinsic, which is discouraged for general use. The goal of this project is to build an ergonomic frontend around a function-like macro together with lightweight abstractions for device management, host-to-device data handling through Device<T>, and compile-time validation of device-compatible types.

pythonrust
Student: Marcelo Domínguez
Code
Proposal

3.1. Improve acceptance test infrastructure

intermediate
Oppia Foundation•2026Varies175h (Medium)

This project aims to improve Oppia’s acceptance test infrastructure by migrating existing tests from Puppeteer to Playwright to enhance stability, maintainability, and developer experience. The migration will be performed incrementally with dual-framework support to ensure CI stability. In addition, the project will address test flakiness by identifying and fixing persistent flaky tests, improving debugging workflows, and enhancing snapshot handling. The project also includes adding safeguards such as lint checks to prevent conflicts in shared utilities during migration. The expected outcome is a robust, maintainable, and reliable acceptance testing system with reduced flakiness and improved developer productivity

pythonjavascriptangularjs+10
Student: Mohak Gautam
Code
Proposal

TechDraw UX Overhaul

intermediate
FreeCAD•2026Varies175h (Medium)

This project will primarily change the command system for TechDraw from a pre-selection to a post-selection. So that the user can click on a command and then the feature they want to annotate. Additionally visual guidance will be added for these commands so it is natural the new post-selection. The tools that cannot be changed to post-selection will instead be grayed-out if the user has not picked a correct feature. Also the toolbars will be changed.

pythonc++qt+2
Student: Morten Vajhøj
Code
Proposal

Empowering OpenSCAD with Local Agentic AI Assistance

intermediate
BRL-CAD•2026Varies175h (Medium)

This proposal introduces an optional, privacy-first AI assistant for OpenSCAD to flatten the learning curve of SCAD syntax and geometric transformations. Integrated as a togglable dock panel, the assistant remains completely inert when closed and requires no cloud subscriptions or external API keys, instead leveraging locally running models via Ollama or any OpenAI-compatible server. Beyond standard Q&A, the project implements agentic behavior where the AI can analyze the active script, propose modifications through an inline diff, and apply approved changes directly to the editor as undoable actions that trigger an automatic preview. The architecture is designed to be vision-model-ready from the start, ensuring future viewport context integration requires no structural refactoring. This creates a transparent, local-only loop that empowers users without compromising the project’s core philosophy of user-controlled development.

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

Implement lossless JPG transformations in the Commons Android App

intermediate
Wikimedia Foundation•2026Varies175h (Medium)

This project is proposed to 1. Prevent the loss in details happening when the user edits, uses the crop/rotate feature when uploading images through the Wikimedia Commons app by replacing LLJTran with JPEGTran which handles details gracefully. 2. Implement Lossless Block-Level Blur The Blur feature at present makes quality loss of image in the process. This is solved by recompression to only relevant blur required pixel blocks then untouched areas wont have loss in details. 3. Auto-detect and blur faces & car number plates. When the user uploads images there is less privacy for random people and car number plates captured by user in the photo use OpenCV to detect faces/plates and apply blur to only region which OpenCV specifies

javascripthtmlphp+7
Student: Rishan
Code

Platform Scalability and Security

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

Kubeflow's adoption at enterprise scale exposes critical bottlenecks in controller efficiency, security posture, and operational overhead. This project delivers six required improvements: (1) ConfigMap-driven database garbage collection for KFP pipeline runs, mirroring the existing artifact_retention_time pattern; (2) ScheduledWorkflow controller migration from legacy client-go informers to controller-runtime; (3) zero-trust NetworkPolicy enforcement for training job namespaces; (4) cross-namespace artifact security hardening with integration tests; (5) KFP dead code removal of deprecated manifests; and (6) Pod Security Standards compliance with CI regression gates. Stretch goals include Gateway API migration, Spark webhook readiness probes, and a Metacontroller migration design doc. This work builds on 12 pre-GSoC contributions (5 merged, 7 open) across 5 Kubeflow repositories.

pythontensorflowkubernetes+5
Student: siddhant_jainn
Code
Proposal

Machine Learning Interatomic Potentials (MLIP) in DeepChem using E(3)-Equivariant Neural Networks

advanced
DeepChem•2026Varies350h (Large)

This project aims to develop a native PyTorch-based Machine Learning Interatomic Potential (MLIP) framework within DeepChem, enabling efficient prediction of molecular energies and forces without relying on external frameworks. MLIPs approximate the potential energy surface of molecular systems, providing a scalable alternative to Density Functional Theory (DFT) for molecular simulations. The project will implement a modular, production-ready framework supporting E(3)-equivariant architectures such as NequIP and MACE, fully integrated with DeepChem’s TorchModel API, graph-based data pipelines, and equivariance utilities. Key deliverables include a generalized MLIPModel abstraction, efficient graph construction and batching pipelines, a stable joint energy–force training system, and comprehensive benchmarking on MD17 and QM9 datasets, including molecular dynamics stability validation. The final outcome will be a fully integrated and extensible MLIP module within DeepChem, enabling end-to-end molecular simulation workflows.

pythonnumpypytorch+1
Student: Satvik Mittal
Code

PictoPy: Expanding into Semantic Intelligence, Memories, Video, and Secure Sharing

advanced
AOSSIE•2026Varies350h (Large)

This proposal aims to implement intelligent event classification, natural language search, and EXIF metadata read-write capabilities for image metadata portability. Key backend upgrades include implementing image metadata based image clustering with SigLIP2 for visual similarity-driven clustering. It introduces application optimization techniques like modular AI model management, allowing users to extend functionality on demand without bloating the base install, to keep the core application lightweight. It improves face clustering accuracy by addressing confirmed gaps in the current DBSCAN pipeline, including adaptive eps estimation and a face quality gate. On the frontend side, a new Memories UI will be introduced with advanced sorting features, user notifications, video support, along with a new landing page for the product launch. A major addition is shareable album links: users will be able to generate secure, token-based links to share selected photos over the network while the PictoPy backend is running, with new API endpoints serving image data directly to a lightweight web-based receiver. Additionally, comprehensive documentation—including contributing guides, API references, and setup videos—will encourage new developers to contribute. These improvements will make PictoPy more user-friendly, scalable, and ready for widespread adoption.

pythonjavascriptswift+8
Student: rohan-pandeyy
Code

Physical AI Inference & Trajectory Upscaling for ros2_control

intermediate
Open Robotics•2026Varies175h (Medium)

AI policies (VLAs, Diffusion Policy) output joint targets at 20–50 Hz, while robot hardware requires continuous commands at 500–2000 Hz. Naively forwarding sparse waypoints causes velocity discontinuities and acceleration spikes that trigger hardware faults or physical damage. Existing solutions are batch-oriented and cannot handle streaming, jittery AI output. This project builds a dedicated Inference-to-Control Bridge in ros2_controllers. It ingests streaming AI waypoints via topics and upscales them to hardware rate using C²-continuous quintic spline transitions, solving the transition problem. A lock-free look-ahead buffer absorbs inference jitter, a time-scaling mechanism handles buffer underrun gracefully, and a safety monitor enforces velocity, acceleration, and jerk limits via time dilation before every hardware dispatch. Deliverables: inference_bridge_controller plugin, quintic spline primitives in control_toolbox, full C++ test suite, and a Gazebo end-to-end demonstration on a simulated 6-DOF arm.

pythonc/c++ros+5
Student: Vedhas Talnikar
Code
Proposal

Python Bindings and Real Time 3D Visualization for OpenTRIM

advanced
Open Technologies Alliance - GFOSS•2026$6k–$13.2k350h (Large)

OpenTRIM is a C++/Qt Monte Carlo ion transport simulator for radiation damage research. Every parameter study today requires four manual steps: edit config.json, invoke the CLI, load HDF5 output, and plot by hand. No Python interface exists. No live view inside the target. This project delivers both. Feature A - Python Bindings: A pybind11 module wrapping libopentrim so researchers drive simulations directly from Python: result = opentrim.run(config_dict). Tally data is exposed as zero-copy NumPy arrays via ArrayNDd buffer protocol. result.to_xarray() returns a labeled Dataset with element names and nm coordinates for publication-ready depth profiles in one line. result.core exposes mccore internals - ion counts, per-tally SEM, and run merging. GSoC 2025 user_tally binning is bridged to Python. Seven benchmark configurations verify physics parity with the CLI. Feature B - Real-Time 3D Visualization: A QOpenGLWidget tab rendering live ion tracks as GL_LINES during simulation. A two-buffer pipeline handles 30M events/second without stalling. Cascade genealogy is color-coded from ion.recoil_id(): beam ions blue, PKAs orange, sub-cascade recoils red. A SEM convergence overlay tells researchers when to stop. Camera state serializes to JSON; --render produces headless PNG with no display server. Both features are isolated - bindings/ and source/gui/trackview.* - delivered across 14 pull requests in 350 hours.

pythonmysqljava+7
Student: DHANAVANTHESH S
Code

Quality Check ToolBox V1.0

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

Problem: There is currently no standalone, open source Python library within the OSIPI ecosystem for post-processing quality control (QC) of Arterial Spin Labeling (ASL) MRI perfusion data. Existing solutions are either MATLAB dependent, closed-source or tightly coupled to specific preprocessing pipelines, making scalable and reproducible QC difficult for clinical and research datasets. Solution: I will build Quality Check ToolBox V1.0 for osipy a pipeline-agnostic, modular Python library that evaluates ASL-derived Cerebral Blood Flow (CBF) maps and generates interpretable PASS/WARN/FAIL triage metrics. Using a configurable registry architecture, it evaluates the Quality Evaluation Index (QEI) alongside orthogonal checks for BIDS compliance, M0 calibration and motion. It features graceful degradation and population-specific YAML configurations (e.g., pediatric, stroke) to successfully distinguish real pathological signals from acquisition artifacts. Deliverables: Core osipy-integrated QC pipeline with a @register_qc_check module registry. Full implementation of the Dolui et al. 2024 QEI metric. Fallback-capable modules for control-label validation, M0 saturation, and motion tracking (FWD/DVARS). Configurable PASS/WARN/FAIL verdict logic that prevents pipeline crashes on missing data. A comprehensive Pytest suite and MkDocs documentation. A standalone HTML visual dashboard for reviewing QC metrics across cohorts.

pythongithub
Student: Agnik Misra
Code
Proposal

Archiving Voided Data

advanced
OpenMRS•2026Varies350h (Large)

In OpenMRS, "voiding" soft-deletes records, causing tables especially immutable ones like Observations (obs) to accumulate massive amounts of inactive data over time. This unbounded growth degrades system performance and complicates database maintenance. This project implements a "Real-Time Archival Trigger" to maintain lean primary tables. When a record is voided, a Hibernate interceptor will execute an atomic transaction to immediately copy the data to a dedicated obs_archive table and hard-delete it from the active table. To manage the infinite growth of the archive, a scheduled background JobRunr task will permanently purge expired records by dropping old partitions from the archive table based on configurable retention policies (e.g., after 7 years).

javahtml5groovy+11
Student: Shivvani Ramadugu
Code
Proposal

Scaling the Meshery Ecosystem

advanced
Meshery•2026Varies350h (Large)

The Meshery ecosystem's web properties need ongoing frontend modernisation and backend reliability work as they scale. I will deliver performance-optimised UI components, mobile-first responsive fixes, new dynamic sections for the extension ecosystem, and systematic infrastructure improvements, all backed by clear documentation. This builds directly on contributions I have been making since December 2025.

javascriptgolangkubernetes+2
Student: Khusham Bansal
Code
Proposal

Apache Beam Add Kafka Streams Runner

intermediate
Apache Software Foundation•2026Varies175h (Medium)

This project will build a portable Kafka Streams runner for Apache Beam so that Beam pipelines can run on Kafka Streams using the Beam Fn API. The runner will translate portable Beam pipeline protos into Kafka Streams topologies and support a working skeleton for core transforms: Read, stateless ParDo, GroupByKey, Combine, non-merging windowing, and Flatten. The implementation will focus on correct watermark propagation, commit-based bundle boundaries, exactly-once semantics, and integration with the existing Beam portability stack. Deliverables include a new runners/kafka-streams module, runner entry points, a pipeline translator with transform-specific translators, watermark and bundle management, tests using TopologyTestDriver and real Kafka-based integration coverage, and documentation for the Beam community.

pythonjavascriptjava+7
Student: Muhammad Junaid Shaukat
Code
Proposal

Graphical interoperability between CyberEther and GNU Radio (OOT module).

advanced
GNU Radio•2026Varies350h (Large)

This project aims to create OOT module, that uses CyberEther's GPU-accelerated framework which uses low-level graphics APIs to create high-performance sinks to visualize GNU Radio data streams in a normal GRC workflow. current implementations of these sinks rely on `gr-qtgui` which is fine but it would be a better to have the option of choosing CyberEther sinks which would be more optimized for maximum throughput and low latency along with a modern design. Main challenges are: minimizing data movement from the GR scheduler to CyberEther tensors, as in high sampling rates unnecessary copying would be expensive and undermine whole native performance edge. Also, CyberEther's current public plotting path internally manages a shared runtime built around `Jetstream::Instance`, and a normal GNU Radio flowgraph can have multiple sinks which would be tricky to manage safely. My core implementation target is a robust first sink family around lineplot and waterfall, with spectrogram support in the second half of the project if the lower-level CyberEther path is needed. These challenges(and other) can be resolved by architecting new solutions which borrow from past implementations namely `gr-cuda` for custom buffers, `gr-cyber` (an earlier prototype from Luigi, the creator of CyberEther) and `gr-fosphor` for relevant challenges.

pythonc++dsp+6
Student: itsYoussef
Code

Implementing ANY_VALUE() and GROUPING() in MariaDB

advanced
MariaDB•2026Varies350h (Large)

This project aims to implement the ANY_VALUE() and GROUPING() functions in MariaDB, addressing longstanding gaps in compatibility with MySQL 8.0 and modern SQL standards. Currently, the absence of these functions limits MariaDB’s usability in applications that rely on advanced GROUP BY semantics, particularly when migrating from MySQL or working with rollup queries. To solve this, I will extend MariaDB’s SQL parser and execution engine to support both functions. For ANY_VALUE(), I will implement a new aggregate function that allows safe selection of non-aggregated columns under ONLY_FULL_GROUP_BY. For GROUPING(), I will introduce a function that distinguishes between NULL values originating from rollup aggregation and those present in the underlying data, by tracking rollup state during query execution. The primary deliverables of this project include fully functional implementations of ANY_VALUE() and GROUPING() in MariaDB, comprehensive MTR test suites validating correctness and MySQL compatibility, and updated documentation describing their usage and behavior. The final outcome will improve MariaDB’s standards compliance and provide developers with essential tools for writing expressive and portable SQL queries.

cmysqlmariadb+7
Student: Jaeheon Shim
Code
Proposal

Physics-Informed Neural Network Shape Optimization

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

Vanilla MLP PINNs suffer from spectral bias and slow convergence, which directly limits the quality of shapes produced by PINN-based shape optimizers. This project integrates Physics-Informed Gaussians (PIG) into the coordinate projection shape optimization framework of Zhang et al. (2024), replacing the MLP physics solver with learnable Gaussian basis functions that adaptively concentrate resolution in high-residual regions. I will build a PyTorch framework with swappable MLP, PIXEL, and PIG physics backends, validate all three on the published iron core torque optimization benchmark, and finally, apply the best-performing backend to a novel use case: optimizing Paul trap electrode geometries to maximize the geometric efficiency factor governing ion confinement. I will explore the open-source framework with backend comparison results and a working Paul trap shape optimizer with fabrication constraints.

pythonmachine learningc+++2
Student: George Liao
Code

Remove the Build Hook Mechanism, Store Extensions

intermediate
NixOS Foundation•2026Varies175h (Medium)

The Nix build hook mechanism has been marked for removal since 2017, but it still fills an important gap in Nix's distributed build architecture. In particular, it is currently the only interface that can pass a build request together with its full set of input paths atomically. Store-based remote building does not provide this: it splits the process into separate calls, which makes it difficult for builder stores that schedule builds across a cluster, such as "nix-scheduler-hook", to know where inputs need to be copied before the build is assigned. This project proposes a cleaner, more extensible replacement by adding a new virtual "buildDerivation" method to the "Store" base class. This method would bundle the derivation path, derivation, and input paths into a single call, preserving the atomic behavior that cluster schedulers rely on. To ensure compatibility, the new interface would include a default implementation so that existing store backends continue to work unchanged. The project will validate this design through an end-to-end proof of concept by adapting "nix-scheduler-hook" to use the new API. Once the new mechanism is confirmed to support distributed scheduling correctly, the legacy build hook mechanism can be removed from the Nix daemon. Expected deliverables include the new virtual "Store" method and its default implementation, full removal of the build hook mechanism from the Nix daemon, a proof-of-concept "nix-scheduler-hook" adaptation, a passing distributed build test suite, and accompanying API documentation and migration guidance.

gitnix
Student: Amrit Amber
Code
Proposal

JBoss Web Server Diagnostic Configuration Validation Toolkit

intermediate
JBoss Community•2026Varies175h (Medium)

This project proposes building jws diag, a read only diagnostic CLI for JBoss Web Server that helps operators and SREs to inspect runtime and configuration state more easily. The tool will provide concise installation and deployment summaries, effective connector TLS and proxy configuration reporting, validation checks for common misconfigurations, structured JSON output, and realistic test coverage for troubleshooting and automation use cases.

androidjavaide+12
Student: Milan P Samuel
Code
Proposal

Parallelizing r.proj and Raster Processing Modules in GRASS

advanced
NumFOCUS•2026Varies350h (Large)

r.proj and r.param.scale are widely used GRASS raster modules that run entirely on a single core, leaving modern multi-core hardware idle. This project parallelizes both using OpenMP. For r.proj, the core blocker is the legacy readcell tile cache which is not thread-safe. The solution is a two-path architecture: a fast RAM-resident buffer for maps that fit in memory, and a thread-local tile cache fallback for larger maps. For r.param.scale, a sequential sliding buffer blocks row-level parallelism. The fix is the same RAM preload pattern: load the full raster before the parallel region and let threads work on rows independently. Proof of concept PRs show 2.5x speedup for r.proj and 1.7x speedup for r.param.scale on 100M cell rasters. r.geomorphon will be audited during the bonding period as a third target. Deliverables include production-quality parallel implementations of both modules, per-thread PJ_CONTEXT initialization, a fix for issue #5776, pixel parity regression tests, scalability benchmarks, and full documentation.

pythonjavascriptr+3
Student: Kaushik Raja
Code
Proposal

Enabling Differentiable Rendering via AD of Parallel C++ STL Primitives in Clad

advanced
CERN-HSF•2026$6k–$13.2k350h (Large)

This project proposes to enhance Clad, a Clang-based automatic differentiation (AD) tool, by leveraging its liveness analysis to automatically generate lock-free backward passes for highly parallel differentiable rendering pipelines. Specifically, the project targets the atomic bottleneck inherent in 3D Gaussian Splatting (3DGS) rasterization. Modern GPU-based differentiable renderers suffer from heavy use of atomic operations (e.g., atomicAdd) during the backward pass because many threads attempt to update the same pixel and gradient buffers simultaneously. This contention overwhelms L2 cache atomic units, stalling execution and causing the gradient computation to consume a significant portion of training time. My approach is twofold. First, I will redesign the rendering pipeline to avoid write conflicts by construction using deterministic sorting, tile-based memory ownership, and local accumulation before a single global write. Crucially, I plan to build this new architecture on top of my previous GSoC work that integrated the Thrust API into Clad. By utilizing Thrust's highly optimized parallel primitives (such as thrust::sort_by_key and thrust::reduce) for the sorting and tile-based operations, we can provide a clean, high-level C++ structure to the compiler. Second, I will utilize Clad to automatically generate the backward pass. By relying on Clad's liveness analysis, the compiler will prove exclusive memory ownership and automatically eliminate the need for atomicAdd calls. To isolate the compiler complexity from the graphics complexity, the project will use a differentiable geometry path tracer as the foundational stepping stone. Beyond differentiable rendering, this work establishes a foundation for compiler-driven automatic differentiation of parallel C++ programs, enabling efficient gradient computation in a wide range of high-performance computing applications.

pythonc/c++machine learning+6
Student: Abdelrhman Elrawy
Code
Showing 481 - 504 of 11996 Projects
1920212223
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal