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

Implementing impl and mut restrictions

intermediate
The Rust Foundation•2026Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

In Rust, trait visibility currently implies implementability. If a trait is visible within a given scope, it can also be implemented in that same scope. However, we do not always want everyone to be able to implement it. To address this, the so-called “sealed trait” pattern is used, which allows a trait to be used while restricting its implementation. This is typically achieved by defining a public trait in a private module. Similarly, field visibility implies mutability. However, we do not always want readable fields to be writable as well. As a result, developers often use private fields together with public getter methods. The Restrictions RFC extends the Rust syntax to be able to explicitly restrict the implementability of traits and mutability of fields. For example, `pub(super) impl(self) trait Trait {}` means that `Trait` can be used within the parent module, while its implementation is restricted to the current module. `pub(super) struct Struct { pub mut(self) field: u8 }` means that `Struct.field` is readable within the parent module, while its mutation is restricted to the current module. These impl and mut restrictions are optional. Although the RFC was accepted in 2022, implementation efforts have stalled. Our goal for this project is to implement both impl and mut restrictions in the Rust compiler.

pythonrust
Student: Ryosuke Yamano
Code
Proposal

Maglev Next Generation REST API Server

advanced
Open Transit Software Foundation•2026Varies350h (Large)

Maglev is OneBusAway's next-generation, high-performance Go REST API server designed to replace the legacy Java architecture. To achieve full production readiness for real-world transit agency deployments, this project focuses on four core deliverables. First, it ensures strict 1:1 API parity through automated, field-by-field output validation against the legacy server integrated directly into CI. Second, it executes a complete Go rewrite of the GTFS merge and transformer modules, creating native CLIs that enable runtime multi-feed loading directly into Maglev. Third, the project integrates the GTFS-Flex specification to support demand-responsive paratransit services, and finally, it expands the existing GTFS-RT pipeline to handle real-time structural trip modifications. Together, these enhancements will transform Maglev from a fixed-route Western transit tool into a globally deployable platform capable of serving diverse transit ecosystems across South Asia, Africa, and Latin America.

androidjavagolang+2
Student: Aditya_Rana
Code
Proposal

Sugarizer ConnectTheDots

advanced
Sugar Labs•2026Varies350h (Large)

This project aims to develop a comprehensive ConnectTheDots activity for the Sugarizer platform that combines creative expression, structured learning, and strategic gameplay into a single unified experience. Currently, Sugarizer lacks an activity that integrates these three aspects. Existing tools typically focus on only one area, leaving a gap for an engaging, multi-mode activity that supports diverse learning styles for children aged 5–11. To address this, the project will implement three core modes using Vanilla JavaScript, HTML5, CSS3, and the Sugar-Web framework: Draw Mode: A free-form mode where children can draw on a dot grid with real-time feedback. Number Mode: A guided learning mode where users connect numbered dots to reveal shapes, with support for custom templates and Journal integration. Game Mode: A strategy-based territory capture game with accurate capture logic and an AI opponent using a greedy heuristic approach. The final deliverable will be a production-ready, optimized activity that runs smoothly on low-end devices and high-DPI touch screens, providing an engaging and scalable learning experience within Sugarizer.

pythonjavascriptgtk++10
Student: Rejah Rabeeul
Code
Proposal

Faust Integration in Godot Game Engine

intermediate
GRAME•2026Varies175h (Medium)

Integration of the Faust programming language into the Godot game engine as the form of an extension (GDExtension) as well as a static version using the faust2xx model. At the end of the project, the following deliverables will be available : · Faust Godot extension available publicly for any version of Godot. · A faust2godot command line tool to compile Faust program into Godot native language statically. · A Godot demo project to show off extension capabilities and help users getting started using the extension. · Technical documentations for both the GDExtension and faust2godot as well as a user manual with examples to make the tools as intuitive as possible to use.

cpythonjavascript+3
Student: Mithaniel V.
Code
Proposal

React Native Performance Improvements

advanced
Meta Open Source•2026Varies350h (Large)

Optimize the React Native bridge and new architecture to improve startup times and animation framerates on lower-end Android devices. (MLH Fellowship)

javascriptpythonc++
Student: MLH Fellow
Code
Proposal

Debezium: Source Connector for SQLite

intermediate
JBoss Community•2026Varies175h (Medium)

SQLite is widely used in mobile, desktop, and edge applications but has no production-ready Change Data Capture connector. This project builds a Debezium source connector for SQLite that captures row-level changes by directly parsing the SQLite Write-Ahead Log (WAL) binary file by decoding B-tree leaf pages, diffing old and new page states, and producing standard Debezium change events with correct before and after values, without any application modifications. Deliverables include a deployable Kafka Connect plugin with full WAL binary parsing, initial snapshot, streaming with safe checkpoint lifecycle management, transaction metadata support, and a complete test suite with documentation.

androidjavaide+12
Student: Siddhant Chaturvedi
Code
Proposal

ML Models that use SBOL for DNA annotation by Shreeya

advanced
National Resource for Network Biology (NRNB)•2026Varies350h (Large)

Developing a scalable and reproducible research pipeline within SeqTrainer for bacterial DNA sequence modelling and annotation using SBOL-based datasets. The project addresses a key challenge in synthetic biology: the lack of accessible, machine learning–ready datasets and standardized workflows for genomic modelling. The primary focus is on E. coli and Gram-negative bacteria, with applications in promoter classification and sequence annotation. The work involves reproducing and benchmarking existing CNN-based baselines, followed by integrating and evaluating foundation models such as DNABERT2 and Evo 2 within structured experiment pipelines. Experiments explore challenges including overfitting and class imbalance through methods such as weighted loss functions, undersampling, learning-rate tuning, and early stopping. A major component of the project is the development of a modular and reproducible experiment framework within SeqTrainer, including configuration-driven workflows, reproducible dataset splitting, evaluation utilities, metric logging, and improved SBOL-to-dataset conversion pipelines with validation and provenance tracking. The final outcome aims to transform SeqTrainer into a more experiment-friendly framework for genomic ML research, enabling accessible, extensible, and reproducible machine learning workflows for synthetic biology researchers.

pythonjavascriptjava+11
Student: Shreeya456
Code

Greedybear: Access payload files

beginner
The Honeynet Project•2026Varies90h (Small)

The goal of this project is to improve GreedyBear’s threat intelligence capabilities by incorporating honeypot payload files received from T-Pot. Currently, GreedyBear only receives and handles metadata such as IP addresses, ports, and credentials from Elasticsearch logs, while actual threat payloads received from honeypots remain unused and inaccessible to analysts . In this regard, this project proposes a secure end-to-end payload ingestion pipeline between T-Pot and GreedyBear. To achieve this, a FastAPI-based microservice will be deployed along with T-Pot to dynamically expose payload files and their associated metadata such as hashes and MIME types via authenticated APIs without altering existing honeypot functionality or imposing additional system overhead. On the GreedyBear end of the pipeline, a scheduled Django Q2 task will be implemented to fetch new payloads and securely store them in a quarantined environment while ensuring deduplication via cryptographic hashes and metadata indexing in PostgreSQL for easy retrieval via a REST API while imposing strict access controls to only allow authorized personnel to download payload files. Moreover, the system will also be designed to optionally share received payloads with MalwareBazaar to contribute to the threat intelligence community as well. In summary, this project aims to greatly improve GreedyBear’s threat intelligence and security analysis capabilities by not only ingesting threat indicators but also threat payloads to become a comprehensive threat intelligence platform for the organization and the entire threat intelligence community at large.

pythonandroidmachine learning+16
Student: Krishna Awasthi
Code
Proposal

Scribe Conjugation Application Development

advanced
Wikimedia Foundation•2026Varies350h (Large)

This project introduces Conjugate, an Android and iOS open-source mobile application that provides a privacy-respecting verb conjugation tool powered by Wikidata. It aims to offer a free and accessible alternative to existing solutions that are often paid or ad-driven. The application will integrate prebuilt SQLite databases to enable fast verb search, real-time autocomplete, and structured conjugation views. Development will reuse existing Scribe-Android components and adopt SwiftUI for iOS, with a focus on modular architecture and performance. Key deliverables include fully functional apps on both platforms, efficient multilingual search, a dynamic conjugation interface, and a well-tested, maintainable codebase that expands the Scribe ecosystem.

javascripthtmlphp+7
Student: Gautham Mohanraj
Code
Proposal

Montage Improvements

intermediate
Wikimedia Foundation•2026Varies175h (Medium)

The proposal is on the project Montage which is the most used photo evaluation tool under WLM ( Wiki Loves Monuments ). The plan is mainly about adding required features and infrastructural upgrades like multi worker system or redis on the project as the amount of entries ( images ) it handles is very high and the current structure barely supports it.

javascripthtmlphp+7
Student: Abhinavmohandas
Code
Proposal

APAP and MCP Server

intermediate
Accord Project•2026Varies175h (Medium)

The APAP MCP server currently routes every tool call through an internal HTTP loop back to its own Express server, adding unnecessary latency, making MCP handlers impossible to unit test, and discarding all HTTP error context behind generic error strings. The MCP layer has zero automated tests and no client-specific documentation beyond a basic setup guide. This project introduces a shared service layer that both MCP tools and REST routes call directly via Drizzle ORM, eliminating the HTTP round-trip. Structured error types replace generic strings with machine-readable codes and HTTP status preservation. Deliverables: 1. Shared service layer refactor with structured error types across all 8 MCP tool handlers 2. Four-tier test suite (unit, integration, contract, E2E) with 90%+ coverage enforced in GitHub Actions CI 3. Client-specific tutorials for Claude, ChatGPT, and MCP Inspector 4. Developer experience improvements: Docker Compose quickstart, Pino structured logging, /healthz endpoint, and updated CONTRIBUTING.md A working proof-of-concept implementing the core refactor with 53 tests and 98.55% statement coverage is already live at github.com/JayDS22/apap-mcp-poc.

javascriptreactcompiler+5
Student: Jay Guwalani
Code
Proposal

Patient-Facing Clinical Trial Chatbot with Interactive Map

advanced
Open Genome Informatics•2026Varies350h (Large)

Cancer patients navigating clinical trial databases face complex search interfaces with dozens of technical filters, making it difficult to find relevant trials without medical expertise. This project builds a patient-facing clinical trial chatbot with an interactive map that removes this barrier through natural language. The system features a three-panel interface: a chat panel powered by an LLM agent that elicits patient information and matches it against the Cancer Trials Canada database, an interactive map that displays geocoded trial site locations and a summary panel that shows trial details when a pin is clicked Built using Chainlit server mounted inside FastAPI, React application with Mapbox GL for the interactive map. Trials are stored in PostgreSQL with pgvector for semantic and full-text search. An open-source LLM served via Ollama and Pydantic-AI. Multi-layered guardrails prevent off-topic or harmful responses, RAGAS for evaluation and Langfuse for observability and tracing throughout development.

pythonjavanodejs+9
Student: Mohamed Amine Haouas
Code

Automated Debian Packaging with debianize

intermediate
Debian•2026Varies175h (Medium)

Debianize is a tools that aims to automatically create debian packages from scratch from upstream source trees. As for the current version, it works for some of the packages but it is not reliable. This projects aims at making it production ready such that it can work with most of the projects. Along with that improving its reliability, coverage, integration with the broader ecosystem and other enhancements.

pythonjavascriptc/c+++8
Student: Anurag Nayak
Code
Proposal

Sunspot Automated Computer Vision Tracking & CME Warning Engine

Intermediate
Royal Observatory of Belgium (STCE / ROB)•2026€2k–€4kStandard (~175h)

Train convolutional neural networks to detect solar flare magnetic field twist precursors on real-time SDO / PROBA-2 satellite coronagraph feeds.

pythonpytorchopencv+1
Dr. Petra Vanlommel, Ronald Van der Linden
Code
Proposal

pgagroal: Advanced security

advanced
PostgreSQL•2026Varies350h (Large)

This project implements true end-to-end TLS pooling for pgagroal by decoupling the cryptographic state from the physical TCP socket. By implementing a clean-room TLSv1.2+ state machine using OpenSSL Memory BIOs, I will establish a Persistent Security Context that can be parked and resumed across pooled connections. Additional deliverables include a proxy-aware SCRAM-SHA-256-PLUS authentication pipeline, robust X.509 Client Certificate validation, and the decommissioning of legacy MD5 pathways to establish a modern, enterprise-grade security boundary.

cpostgresqlperl+8
Student: trxvor
Code
Proposal

Adding WebAssembly Linking Support to Wild

advanced
The Rust Foundation•2026Varies350h (Large)

This project aims to add WebAssembly support to the Wild linker. Wild linker is a high-performance Linux linker written in Rust, and supporting the WebAssembly format would expand its applicability to even more Rust development scenarios. While LLVM's wasm-ld (lld) is currently the primary linker used for WebAssembly, Wild achieves link speeds that are often several times faster than lld for ELF linking across many scenarios, including mold, which was previously considered the fastest Linux linker. Since the fundamental linking process remains largely the same when adding WebAssembly support, much of the performance-critical implementation could be reused. Achieving similar performance gains for WebAssembly would therefore significantly reduce build times for Rust projects.

pythonrust
Student: Kei Akiyama
Code
Proposal

EcoGrid Intelligence: AI-Driven Climate Resilience Analysis

intermediate
Liquid Galaxy project•2026Varies175h (Medium)

EcoGrid Intelligence: AI-Driven Climate Resilience Analysis for Global Energy Infrastructure on Liquid Galaxy is an AI-driven geospatial analysis system designed to proactively identify global energy infrastructure at risk of operational failure due to severe climate events such as heatwaves, droughts, and wind anomalies. It addresses the problem of critical infrastructure and meteorological data being siloed, which prevents stakeholders from achieving a unified, spatial understanding of risk. The solution dynamically fuses live climate anomalies with global energy infrastructure maps to create an interactive analytical canvas on the Liquid Galaxy platform. The EcoGrid Intelligence system follows a layered architecture: Data Sources and Risk Assessment: Climate Data: Streams live and forecasted climate anomalies, including temperature deviations, precipitation extremes, and wind intensity, from the Open-Meteo API. Infrastructure Data: Geospatial coordinates, generation type (hydro, nuclear, solar), and operational capacity are sourced from the Global Power Plant Database. Risk Model: A deterministic model computes a Climate Vulnerability Score (CVS) by evaluating localized anomaly intensity against the plant type's operational sensitivities. AI Orchestration: Google’s Gemini models act as the system’s brain to autonomously determine region-relevant climate anomalies, trigger API calls, interpret the resulting CVS metrics, and structure the output for spatial rendering. Visualization: The results are converted into Keyhole Markup Language (KML), generating elements like Placemark, LookAt, and FlyTo for native, synchronized rendering and camera guidance on the Liquid Galaxy multi-screen rig. Outputs: Primary displays render immersive climate anomaly heatmaps and color-coded nodes indicating vulnerability levels, while secondary screens display dynamically generated HTML content and AI-driven insights.

javascriptrosgis+14
Student: Bhoomi Shivhare
Code

OpenVINO Profiling using VTune & GTPin

advanced
OpenVINO Toolkit•2026Varies350h (Large)

The existing GPU profiling workflow in OpenVino, through benchmark_app connects kernels to the model layers (primitives) and reports their execution times. However, this level of abstraction is too coarse to identify kernel instruction level insights. Intel GTPin, on the other hand, provides instruction level GPU kernel metrics like clock cycle counts, but is unable to directly map such metrics to specific inference or layers. This project aims to build a GTPin-centered profiling capability within OpenVINO to identify hotspot kernels and analyze their execution characteristics. The approach involves integrating controlled GTPin profiling into the inference flow, developing a custom GTPin tool for collecting kernel-level metrics, and progressively interpreting these metrics using signals from OpenVINO performance counters, and kernel metadata. The expected deliverable is a GTPin-based profiling workflow integrated into OpenVINO, capable of identifying bottleneck kernels, providing insight into their behavior, and offering indicative optimization directions, with validation using tools such as VTune.

pythonc++x86+1
Student: Jayakaran
Code
Proposal

Port std::arch test suite to rust-lang/rust

intermediate
The Rust Foundation•2026Varies175h (Medium)

The std::arch in the standard library provides architecture-specific intrinsic functions, which directly map to a single machine instruction. The ultimate goal is to inline stdarch into rustc completely and archive the stdarch repository making stdarch tests reliable and maintainable inside rustc infrastructure. Which we will achieve by incrementally investigating the CI test suite of stdarch and port as much of it into rust-lang/rust. The clear set of deliverables for this project are Map stdarch CI to rustc, land x.py steps for verify + stdarch tests, enable core_arch (plain then assert_instr on Linux), port intrinsic-test in phases (host, then cross if feasible), minimal stdarch-gen checks, wire CI, document, final report.

pythonrust
Student: xonx4l
Code
Proposal

Automated Software Performance Monitoring for the ATLAS experiment

beginner
CERN-HSF•2026Varies90h (Small)

At present, software regression testing at ATLAS is predominantly performed manually via inspection of metrics on the ATLAS project management board. This process is both time-consuming and error-prone, and it does not provide any easy way to identify potential root causes of a given decrease in software performance. To ensure reliability and robustness, it is necessary to design mechanisms which can autonomously detect anomalies and failures at scale as they occur. I will resolve these shortfalls by modifying the SPOT orchestration scripts to incorporate an automated anomaly detection pipeline which can issue alerts upon detecting anomalies. Statistical and machine learning approaches will be employed to detect anomalies, and tested, validated and verified on existing data. Additionally, I will also upgrade the performance monitoring board to provide improved at-a-glance visibility of recent anomalies to ease diagnosis and resolution.

pythonc/c++machine learning+6
Student: Douglas Lindsay
Code

Building a machine-learning taxon classifier for genomic classification in malaria mosquitoes

advanced
MalariaGEN•2026Varies350h (Large)

This project aims to build a machine-learning taxon classifier for genomic classification in malaria mosquitoes, operating directly on raw sequencing reads (FASTQ files). Accurate taxonomic identification is essential for malaria vector genomics, since many Anopheles mosquitoes are morphologically indistinguishable and misclassification can lead to incorrect downstream analyses, flawed epidemiological interpretation, and suboptimal control strategies. Current approaches typically rely on genotype calls produced by variant-calling pipelines. While effective, these approaches introduce additional computational cost and complexity, and they are less convenient in settings where only raw reads are available. The goal of this project is to develop a lightweight FASTQ-based classifier that can guide a sample to the correct major taxonomic group or downstream genomic resource without requiring full genotyping or fine-scale species splitting. Rather than attempting detailed resolution within closely related complexes at the outset, the classifier will focus on robust assignment to broader taxonomic groupings or reference frameworks, such as An. gambiae, An. funestus, or An. stephensi.

pythonGCS
Student: Sadat Bashir
Code
Proposal

Apache NuttX- Create a NuttX Distribution Layer with Dynamic ELF Application and Library Support

intermediate
Apache Software Foundation•2026Varies175h (Medium)

Apache NuttX already supports ELF loading and shared objects, but it still lacks a practical lifecycle layer for installing, updating, versioning, and rolling back applications after the base firmware is deployed. This project will build a thin distribution helper on top of existing NuttX services instead of introducing a full package-manager ecosystem. The work will target a supported ESP32-S3 board with PSRAM and use sim for reproducible early validation. The implementation will reuse existing NuttX subsystems such as NSH, filesystems, networking, and BINFMT/ELF loading, while adding the missing pieces: local metadata, versioned application storage, direct dependency handling, staged activation, rollback, and shared-library reuse rules. The main deliverables are: reproducible ELF/shared-object validation on current mainline, a working on-device application update flow with rollback, support for reusing packaged shared libraries, documentation for sim and hardware validation, and reviewable upstream changes integrated with Makefile and CMake workflows.

pythonjavascriptjava+7
Student: Aviral Garg
Code

Controller Area Network (CAN) Stack Improvement: BeagleBone Black D-CAN Driver Implementation

intermediate
RTEMS Project•2026Varies175h (Medium)

This project implements a D-CAN driver for the AM335x controller on the BeagleBone Black and integrates it into the RTEMS CAN stack, addressing the current lack of CAN support for this widely used embedded platform. This enables RTEMS applications to access CAN communication through standard interfaces such as /dev/canX. The main challenge lies in bridging the mismatch between the mailbox-based D-CAN hardware architecture and the queue-based abstraction used in RTEMS. To address this, the driver will introduce a mapping layer that emulates FIFO-based reception using hardware message objects and implements a software-managed, priority-aware transmission mechanism. Synchronization will be carefully handled through IFx register access and interrupt management to ensure correctness and real-time behavior. The implementation will follow an incremental approach, starting with a minimal working driver (initialization, polling-based TX, FIFO RX), and then extending to interrupt-driven operation, improved mailbox utilization, and priority-aware scheduling. Validation will be performed on real hardware using loopback and cross-platform communication tests (RTEMS ↔ Linux). Deliverables include a fully functional and maintainable D-CAN driver integrated into RTEMS, along with documentation, test demonstrations, and validation results. This work will also serve as a reference for future CAN driver development within the RTEMS ecosystem.

cpythonembedded systems+5
Student: riverquiet
Code

Modernizing the DSOMM Application: Angular 13 to 21

intermediate
OWASP Foundation•2026Varies175h (Medium)

DSOMM's Angular frontend currently runs on Angular 13, a version that reached end-of-life in 2023 and is eight major versions behind the latest release. This project migrates the application to Angular 21 through three workstreams: 1. An incremental version upgrade, 2. Adoption of Angular Signals to replace imperative state management, and 3. Packaging key views as Angular Elements for third-party embeddability. The migration follows Angular's official upgrade path, with tests and documentation updated at every step, leaving the codebase in a state that future contributors can build on rather than work around. #dsomm

pythonjavascriptjava+10
Student: sawankshrma
Code
Proposal
Showing 217 - 240 of 13453 Projects
89101112
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal