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

Hybrid 3D CNN with Deformable Attention and FNO for CAC Segmentation

advanced
Machine Learning for Science (ML4SCI)•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 develops a high-precision, clinically viable pipeline for segmenting Coronary Artery Calcium (CAC) from non contrast cardiac CT scans using the Stanford COCA dataset. The core innovation is a Hybrid 3D U Net architecture that balances the local inductive bias of CNNs with the global context of Transformers, specifically optimized for the extreme sparsity of calcified lesions. The architecture integrates 3D Deformable Attention to bypass O(N^2) scaling and CoordConv for anatomical grounding, effectively suppressing false positives from osseous structures like ribs. A primary research contribution is the experimental Fourier Neural Operator (FNO) bottleneck, which tests the hypothesis that calcified plaques can be isolated as high-frequency signals in the spectral domain. To ensure clinical utility, the model is trained using Scoring-Driven Consistency (SDC) a differentiable volume score loss that aligns optimization with the Agatston metric. Deliverables include a MONAI based preprocessing pipeline, a rigorous benchmark against an nnUNet gold standard, and a fully automated Agatston scoring engine for risk categorization (0, 1–99, 100–399, ≥400). This work aims to bridge the gap between architectural novelty and real world diagnostic accuracy for cardiovascular risk stratification.

pythonmachine learningc+++2
Student: Rajat Nandkumar Shedshyal
Code
Proposal

IM Wrapper Plugin Proposal For Care (with POC)

beginner
Open HealthCare Network•2026Varies90h (Small)

Accessing medical data through the care web app can be daunting for patients in rural or remote areas who often face challenges with digital literacy, internet connectivity or lack of access to computers. Currently, retrieving appointments, health records etc requires users to log in and navigate the care web app, which makes it difficult for those with limited digital exposure to access their essential medical information. This project introduces an Instant Messaging wrapper for the care EMR, built as a django plugin. Which allows patients and staff to securely fetch medical records, check appointments etc and receive alerts and notifications through familiar, easy to use messaging apps like WhatsApp. To ensure HIPAA security compliance, the system uses a 2 step authentication process which includes (1). matching phone number and (2). verifying requestor's date of birth. It will also include redis based caching, ratelimiting of requests to prevent abuse and async task management via celery to handle sending of notifications in the background. A frontend plugin will also be developed to give staff the ability to easily send alerts and notifications and allow patients to download PDFs, such as medications and lab reports. Deliverables: 1. A functional, django based backend plugin, capable of securely serving patient and staff queries via various instant messaging providers. 2. A frontend developed using care_hello_fe to manage notifications and handle PDF downloads. 3. Proper tests utilizing pytest and Playwright for both the backend and frontend. 4. Complete and comprehensive documentation using sphinx and swagger, along with setup guides and demo videos. 5. Production ready deployments of both the backend and frontend plugins integrated within care.

pythondjangoreact+2
Student: Samiullah Javed
Code
Proposal

Optimizing Casanovo for Real Time De Novo Peptide Sequencing

intermediate
OpenMS Inc•2026Varies175h (Medium)

Casanovo is a transformer-based de novo peptide sequencer that is too slow for real-time instrument use. I will profile the new non-autoregressive pipeline, apply CUDA graphs, mixed precision, and FlashAttention-2 to reduce per-spectrum latency, then train lightweight student models via knowledge distillation to reach the 20-100 Hz real-time target required by modern mass spectrometers.

pythoncythonc+++2
Student: Gaurav SRC
Code
Proposal

WildFly Elytron Native PEM KeyStore for Kubernetes TLS Secrets

intermediate
JBoss Community•2026Varies175h (Medium)

This project adds native PEM keystore support to WildFly Elytron, enabling WildFly to load Kubernetes TLS secrets directly without any manual conversion. Kubernetes exposes TLS certificates and private keys as PEM files, typically as tls.crt and tls.key. Elytron currently requires JKS or PKCS12 keystores, which creates unnecessary friction when deploying applications in containerized environments. This project introduces a new KeyStoreSpi implementation that reads PEM-encoded certificates and private keys from separate files and exposes them as a standard keystore type (PEM). The implementation integrates seamlessly with Elytron’s existing KeyManager and TrustManager infrastructure, allowing it to be used transparently in current configurations. The main deliverables include a robust PEM parser, the PemKeyStoreSpi implementation, support for separate certificate and key files, Elytron configuration integration, comprehensive test coverage, validation using Kubernetes-style TLS secrets, and clear user documentation.

androidjavaide+12
Student: CharlieZhang
Code

Demonstrating integration of openhands with OpenVINO Model Server

intermediate
OpenVINO Toolkit•2026Varies175h (Medium)

This proposal aims to create a production-ready, single-command deployment integrating the OpenHands AI coding agent with the OpenVINO Model Server (OVMS) on Intel AIPC hardware. The project resolves three critical friction layers: the API routing mismatch between OVMS (/v3) and OpenHands (/v1), the failure of structured tool-call execution which leads to model hallucinations, and system crashes caused by memory exhaustion from concurrent Docker sandboxes. By implementing a Docker Compose manifest with shared bridge networking and host Docker socket passthrough, the architecture offloads heavy LLM inference to iGPU or NPU targets while keeping orchestration on the CPU. Key technical deliverables include configuring native tool-guided generation for models like Qwen3-Coder-7B, enabling prefix caching to reduce multi-turn latency by over 50%, and enforcing strict container memory limits to ensure stability on 8 GB and 16 GB RAM profiles. The project concludes with a formal usability gap analysis and a finalized deployment setup to provide a seamless, local, and private AI development environment

pythonc++x86+1
Student: devesh-047
Code
Proposal

SciML Comprehensive Non Uniform Grid Support for MethodOfLines

advanced
NumFOCUS•2026Varies350h (Large)

This project aims to deliver comprehensive, end-to-end non-uniform grid support for MethodOfLines.jl. Currently, basic advection schemes lack graceful error handling for ill-posed boundary conditions, and advanced high-order schemes (specifically WENOScheme) completely lack non-uniform method dispatch, leading to fatal compilation errors on irregular domains. The proposed solution utilizes Julia's multiple dispatch to route non-uniform grids to a newly developed, isolated mathematical weight calculator within the WENO module, ensuring zero breaking changes for existing uniform grid users. Key deliverables include refactored basic advection schemes with robust well-posedness validation, a native non-uniform WENO implementation featuring dynamic smoothness indicators and negative weight regularization, rigorous L₂ convergence tests, performance benchmarking, and comprehensive documentation to enable highly precise real-world physics simulations.

pythonjavascriptr+3
Student: Utku Yilmaz
Code
Proposal

glmmTMB via RTMB

advanced
R project for statistical computing•2026Varies350h (Large)

This project's goal is to improve the accessibility and sustainability of the glmmTMB R package by replacing its C++-based TMB backend with a more user-friendly, R-like RTMB framework. While TMB provides high performance, its reliance on C++ limits contributions from the broader R community. Transitioning to RTMB will lower this barrier and allow more developers to extend the package. I will convert the core computational parts of glmmTMB into RTMB, validate correctness using existing unit tests, and benchmark performance on large datasets. The project will include updating the build infrastructure and improving documentation to support future contributions. The final deliverable will be a fully functional RTMB-based backend with strong performance and increased usability.

cc++r+4
Student: divitp
Code
Proposal

Redesigning the translation memory tab

intermediate
KDE Community•2026Varies175h (Medium)

Lokalize has Translation Memory tab that opens up after selecting from Tools menu or pressing F7. It has TM(Translation Memory) entries, each for a distinct project listed in a drop down to select from. Translators would like to select not a single TM but a bunch of TMs, for each project, pertaining to their needs. Manage TMs option which opens up in a new window. Logically and for the ease of work, it should be situated in the TM tab itself. The key idea is to use QListWidget with checkboxes instead of KComboBox to enable multi-TM selection. Then, the setFilter() will be modified to iterate over each selected TM. A new method mergeAndDisplay() will be created for merging, deduplication, and sorting of entries according to score. TM selection will persist with the help of KConfig. The core base classes, DBs and architecture are to be retained. A QSplitter will be used to create a left panel to integrate TM Manager into TM Tab to list TMs and a right-click context menu for operations like Add, Remove etc. which will be wired to existing methods. Deliverables: ·List of TM entries with a checkbox for each ·Display results from all selected TMs after Search in TM Tab ·Save TMs for each project ·TM Manager in the left panel of TM tab

c/c++qtqml+6
Student: Navya Sai Sadu
Code
Proposal

Implement RFDiffusion and RFDiffusion All-Atom in DeepChem

advanced
DeepChem•2026Varies350h (Large)

RFDiffusion (Watson et al., Nature 2023) is the state-of-the-art protein backbone diffusion model but DeepChem currently has no protein structure generative model. This project implements RFDiffusion and RFDiffusion All-Atom as native DeepChem TorchModel subclasses, covering a SE(3)-equivariant denoiser with Invariant Point Attention, a RoseTTAFold-style multi-track architecture, SO(3) diffusion for rotations, conditioning mechanisms (motif scaffolding, symmetry, binder design), the all-atom extension for side chains and small molecules, and a full evaluation pipeline. Deliverables include merged PRs for the featurizer, CATH dataset loader, core layers, and the complete model, along with benchmark results and a tutorial notebook.

pythonnumpypytorch+1
Student: chidwipak
Code
Proposal

Annotation Metrics Reporting and Analysis Modules for the Ensembl Assembly/Annotation Tracking App

intermediate
Genome Assembly and Annotation•2026Varies175h (Medium)

The Ensembl Assembly/Annotation tracking application stores rich quality metrics for thousands of genome annotations but currently lacks tooling to surface or compare them in a way annotators can act on. This project builds two Python modules on top of the existing backend services. The first generates structured per-genome annotation reports including BUSCO scores, coding gene counts, annotation method, and visualisations. The second enables taxonomy-grouped comparative analysis using PCA and outlier detection across clades, so annotators can immediately see whether a genome looks unusual relative to phylogenetically similar species. Both modules extend the existing services layer (annotations_service.py, report_annotation_service.py, report_assembly_service.py, taxonomy_service.py) without replacing anything, follow the ensembl-genes coding standards (pylint, mypy, black, pytest), and are built to be extended as the data model grows.

pythonmysqljavascript+4
Student: Shrinidhi
Code

Browser-Native Genomic Feature Search using SQLite WASM and JBrowse

advanced
Genome Assembly and Annotation•2026Varies350h (Large)

This project implements a browser-native genomic feature search system for efficiently querying large GFF3 annotation datasets without requiring backend infrastructure. Traditional approaches either rely on slow client-side parsing or require server-side APIs, both of which introduce scalability and maintenance challenges. The proposed solution converts GFF3 files into an indexed SQLite database offline and performs full-text search queries directly in the browser using SQLite WASM within a Web Worker. The system integrates with JBrowse to enable seamless navigation from search results to genomic locations, providing a responsive and interactive user experience. To support large metagenomic datasets, the system will incorporate range-based loading and progressive data access strategies. The final outcome will include a production-ready indexing pipeline, a browser-based query engine, performance benchmarks, and a reusable React component that can be integrated across multiple EMBL-EBI web applications without requiring backend services.

pythonmysqljavascript+4
Student: Muhammad Ali Arif
Code

Continue AI-Powered Chatbot for Quick Access to Jenkins Resources

intermediate
Jenkins•2026Varies175h (Medium)

The Jenkins Resources AI Chatbot can answer "how do I install this plugin?" but it can't tell you why your build broke, whether two plugins conflict, or whether last week's prompt change made answers worse. This project fixes that: an LLM-as-a-Judge evaluation pipeline, GraphRAG for relational plugin queries, a Build Failure Diagnosis Agent, and simplifed plugin setup all built directly on top of the existing chatbot-core architecture.

javascriptjavago+2
Student: Mallikarjun G D
Code
Proposal

LensMint Compression Resilient ZK Proofs and Rust Upgrade

advanced
C2SI•2026Varies350h (Large)

LensMint is an innovative Web3 hardware camera, but its reliance on strict cryptographic hashing makes Zero Knowledge proofs fail upon benign image compression. This project upgrades the authenticity pipeline by introducing Perceptual Hashing and a Hamming Distance ZK circuit in Rust to tolerate compression. Additionally, it implements a comprehensive Foundry security suite with maximum test coverage and optimizes gas consumption for the core smart contracts.

pythonjavago+2
Student: Tenerife
Code
Proposal

Molly.jl: Machine Learning Potentials for Molecular Dynamics

advanced
The Julia Language•2026Varies350h (Large)

Classical force fields in molecular dynamics are fast but cannot capture bond breaking, charge transfer, or complex many-body chemistry. Machine learning potentials (MLPs) close this gap — offering near-quantum accuracy at a fraction of ab initio cost. Molly.jl currently supports MLPs only through a Python bridge (ASECalculator), which requires a Python runtime and bypasses Julia's differentiable programming stack entirely. This project delivers native Julia support for four widely-used MLP families: ANI (neural network potential for organic molecules), ACE (linear body-ordered basis expansion), NequIP, and Allegro (E(3)-equivariant graph neural networks). ANI is implemented from scratch in pure Julia using Lux.jl, with pre-trained ANI-1x/ANI-2x weights loaded from HDF5. ACE is integrated via the mature ACEpotentials.jl package. NequIP and Allegro are wrapped from TorchScript-exported models via PythonCall, following the existing ASECalculator pattern. All four potentials plug into Molly.jl's general_inters dispatch loop with zero changes to core simulation code. Pure-Julia models (ANI, ACE) are fully differentiable via Enzyme reverse-mode AD and GPU-accelerated via KernelAbstractions. The result: researchers can run differentiable, ML-accelerated molecular dynamics entirely within Julia — no Python, no overhead, composable with the full SciML ecosystem.

cjavascriptc+++12
Student: Siva Sathyaseelan
Code

Energy Consumption Modeling and Power Aware Extensions for 5G LENA

intermediate
The ns-3 Network Simulator Project•2026Varies175h (Medium)

The CTTC 5G-LENA NR module provides a highly detailed and validated simulation of the 5G NR protocol stack within ns-3. However, a critical dimension currently missing is energy consumption modeling. Neither the UE nor the gNB reports power draw or connects to the existing ns-3 Energy Framework. This gap prevents researchers from studying vital metrics like UE battery lifetime, gNB operational expenditure, and overall green networking sustainability. This project will introduce a mature, callback driven energy tracking architecture to the 5G NR module by integrating it with the ns-3 Energy Framework.

pythonc++c/c+++2
Student: Nipuna Dulara
Code
Proposal

Linear attention vision transformers for end to end mass regression and classification

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

This project addresses a key challenge in High Energy Physics: efficient and accurate end-to-end reconstruction of particle properties from detector data. In the CMS experiment at the Large Hadron Collider, particle collision events can be represented as high-resolution, multi-channel images. The goal is to simultaneously classify particle types and regress their invariant mass directly from these images. A major limitation of existing Vision Transformer (ViT) approaches is the quadratic computational complexity of softmax attention, which makes them inefficient for large-scale detector data. While linear attention mechanisms reduce this complexity, they often struggle to capture rich global interactions and multi-channel dependencies required for physics tasks. To address this, this project proposes the development of linear-attention-based Vision Transformers tailored for CMS E2E tasks, with a strong focus on extending the DepthViT architecture. The approach consists of three key components: Efficient Representation Learning A linear attention ViT with Masked Autoencoder (MAE) pretraining will be used to learn strong representations from large-scale unlabeled CMS data, improving downstream performance and convergence. Architecture Adaptation (DepthViT Extension) The DepthViT architecture will be adapted for supervised classification and regression by: Introducing dual-task heads for classification and mass regression Preserving depth-channel and rank structure in later layers to avoid information collapse Integrating Hierarchical Attention Permutable (HAP) blocks to enable efficient cross-window and cross-channel information flow while maintaining linear complexity Systematic Benchmarking The proposed models will be rigorously compared against standard and efficient transformer baselines (ViT, Swin, L²ViT, XCiT) using: Physics metrics (accuracy, MAE, R²) Efficiency metrics (FLOPs, memory, throughput)

pythonmachine learningc+++2
Student: Krish Malik
Code

Multicategory Support for Joomla Items

intermediate
Joomla!•2026Varies175h (Medium)

Problem: Currently, Joomla items such as articles are limited to a single category, which makes it difficult to organize content that belongs to multiple contexts. While tags are sometimes used as a workaround, they do not integrate with core features such as routing, menus, and structured layouts in the same way as categories. Solution: This project introduces multi-category support by implementing a generic mapping table (#__category_item_map). It preserves backward compatibility and SEO integrity by using a "Primary Category" as the main reference for routing, workflows, and parameter inheritance. Deliverables: A new database schema, an updated backend interface for multi-category selection, frontend updates to reflect multi-category assignments in item views and category listings, model-level integration for custom fields, extended batch operations, unit tests, and documentation.

javascripthtmlphp+7
Student: Reda Shewil
Code
Proposal

S3 Backend for RNTuple

advanced
CERN-HSF•2026Varies350h (Large)

RNTuple is ROOT's next-generation columnar data format for High Energy Physics. Its storage layer is decoupled from its format layer, enabling new backends. This project implements a S3 storage backend for RNTuple, allowing datasets to be written to and read from S3-compatible object stores such as CERN's Ceph S3 and AWS S3. The approach introduces a new S3 locator type with two addressing modes: packed pages with multi-range GET for servers that support it, and one-page-per-object with concurrent GETs for those that do not. A JSON anchor at the base URL provides the entry point with a templated URL scheme for forward compatibility. The implementation adds RPageSinkS3 and RPageSourceS3 classes using the existing RCurlConnection as the transport layer, extended with PUT support and concurrent I/O via curl multi handles. Deliverables include the complete write path (Phase 1-2), complete read path with optimized cluster loading (Phase 3-4), RCurlConnection extensions for PUT and concurrent I/O, and a comprehensive test suite covering wire-level tests, locator round-trips, integration tests against MinIO and CERN Ceph S3, and performance benchmarks.

pythonc/c++machine learning+6
Student: Jas Mehta
Code
Proposal

Service Queues

advanced
OpenMRS•2026Varies350h (Large)

The OpenMRS O3 Service Queues app manages outpatient clinic flow but suffers from performance issues due to over-fetching deeply nested objects via custom REST representations, UI components that diverge from O3 design conventions and broken interactions including non-functional buttons and silent failures. This project builds a dedicated REST endpoint in openmrs-module-queue following the emrapi PR #250 pattern, returning only the data the queue table needs with server-side pagination and batch loading. Visit details are lazy-loaded on row expansion. On the frontend, the custom vitals component is replaced with the shared patient-vitals-info extension, encounter parsing is standardized to use configurable concept UUIDs and SWR data-fetching is optimized with activity-aware revalidation. All broken buttons are either fixed or removed. Deliverables include the dedicated backend endpoint with database indexes, frontend migration with lazy-loaded visit details, UI alignment with O3 conventions, fixed interactions with proper error handling, activity-aware SWR optimizations and comprehensive Playwright E2E tests with before/after performance benchmarks.

javahtml5groovy+11
Student: UjjawalPrabhat
Code
Proposal

Dynamic DICOM Endpoints for Diomede

advanced
Alaska•2026$6k–$13.2k350h (Large)

Teleradiology in underserved regions such as rural Alaska depends on reliable, low-latency transfer of large DICOM medical imaging files between remote clinics and reading centers. Today, these transfers are governed by static configurations - a fixed IP address, port, and Application Entity (AE) Title standardized decades ago. This breaks silently when SCP nodes restart, IPs change, or storage queues fill. This proposal introduces Dynamic DICOM Endpoints, an intelligent orchestration layer integrated with the open-source Orthanc PACS server and Docker containers on the Cloud. A FastAPI Orchestrator backed by a real-time Redis registry continuously monitors the health, latency, queue depth, and storage capacity of every Orthanc node in a multi-region deployment, selecting the optimal routing destination in milliseconds and replacing fragile static pipes with a self-healing, load-aware mesh. Deliverables include a four-region Docker Compose simulation environment; a Python telemetry daemon; a pluggable scoring algorithm; a thin Edge Agent bridging legacy scanners (GE, Siemens); a comprehensive test and benchmarking suite validating routing correctness, failover behavior, and transfer performance; and a documentation suite. All code will be contributed as open-source to the Diomede repository, directly improving imaging infrastructure for remote and resource-constrained healthcare settings. As part of my pre-proposal engagement with the host organization, I submitted Issues #59, #79, and #85, along with the corresponding PRs #60, #80, and #86, to the Diomede repository. This contribution demonstrates my familiarity with the project's codebase and development workflow, and establishes a collaborative relationship with the maintainers ahead of the GSoC coding period.

pythonmysqljava+2
Student: Jessi Huang
Code
Proposal

Modernize the iOS App UI

intermediate
Open Transit Software Foundation•2026Varies175h (Medium)

This proposal aims to modernize the OneBusAway iOS app by replacing the current tab bar navigation with a SwiftUI-based, Apple Maps–style sheet interface. It involves removing the legacy navigation system and introducing a new SwiftUI root view with a persistent bottom sheet that unifies key features, including search, nearby stops, arrivals, bookmarks, recent stops, and settings. The project will also ensure full VoiceOver accessibility support and establish a scalable SwiftUI foundation, enabling future features and incremental migration without revisiting the navigation architecture.

androidjavagolang+2
Student: Mohamed Sliem
Code
Proposal

Improving The Traffic Manager of the P4Sim Switch

advanced
The P4 Language Consortium•2026Varies350h (Large)

This project is to improve the P4Sim module by enhancing its Traffic Manager and integrating ns-3's built-in QueueDisc class into it. This will help developers and researchers in testing P4 switches with more complex scenarios and get accurate results for their experiments.

llvmc++mlir+3
Student: Vineet Goel
Code
Proposal

Implementing a Formal Experimental API Framework for Django Core

intermediate
Django Software Foundation•2026Varies175h (Medium)

This project introduces a formal Experimental API Framework for Django by modernizing DEP 2. It implements a three-tier opt-in architecture utilizing virtual namespaces (django.experimental), centralized feature flags, and decorator engines. By establishing strict governance lifecycles and build-time safety mechanisms like an "LTS Kill-Switch", this project allows the core team to safely test, iterate, and graduate new features based on real-world feedback without compromising Django's strict backward compatibility guarantees.

pythondjango
Student: Praful Gulani
Code
Proposal

Enhancing Zoned Storage support on FreeBSD

intermediate
The FreeBSD Project•2026Varies175h (Medium)

This proposal aims at implementing the following quality-of-life improvements to FreeBSD's Zoned Storage support: NVMe ZNS support; Zone-aware gconcat(8), gpart(8) and gmirror(8); Two new GEOM drivers: one for emulating zoned storage, another to emulate regular disks backed by a zoned drive.

c/c++llvmassembly+5
Student: voidanix
Code
Proposal
Showing 1105 - 1128 of 11996 Projects
4546474849
Proposal
Proposal
Proposal
Proposal
Proposal