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

BLT University: Interactive Security Labs with Vulnerability Insights

intermediate
OWASP 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)

BLT University is an interactive security learning platform built on top of OWASP BLT that transforms existing labs into hands-on, code-driven exercises. It migrates the current Django-based labs into a static Jekyll system where content is stored and rendered as Markdown, making it more scalable and easier to maintain. Instead of static, theory-heavy content, users work directly with vulnerable code through a structured Identify → Explain → Fix workflow to understand how vulnerabilities appear and how to fix them in practice. The project also includes GitHub Actions workflows for validation and syncing, along with a security intelligence pipeline that analyzes GitHub issues, pull requests, and review comments to identify recurring vulnerability patterns. These insights power a dashboard and a recommendation system, helping connect real-world security issues with relevant labs and improve hands-on learning for contributors. It aims to help contributors build a practical security mindset while improving the quality of open-source contributions.

pythonjavascriptjava+10
Student: Sakshee suman
Code
Proposal

Support WASM as a Neovim Build Target

intermediate
Neovim•2026Varies175h (Medium)

Neovim currently cannot run natively in web browsers because its build systems and dependencies, such as libuv rely on OS-level features unavailable in WebAssembly (WASM). This project aims to enable Neovim as a WASM build target by adapting its build systems, creating a WASM compatibility layer to stub or replace unsupported OS features, and integrating a browser frontend. It involves compiling Neovim’s core editing engine, Lua 5.1 interpreter, and runtime files into WASM, adapting asynchronous event loops, handling virtual filesystems via Emscripten, and providing replacements for system calls like signals, threads, and process management. The deliverables include a fully functional nvim.wasm binary with embedded runtime files, a browser frontend capable of rendering the UI and handling input via Neovim’s RPC protocol. This will allow Neovim to operate within the browser which increases accessibility, enables integration with online IDEs and educational platforms, and expands Neovim’s ecosystem to new users and contributors.

cpythonjavascript+4
Student: Rawan Khalid
Code
Proposal

Pipewire support for Mixxx

intermediate
Mixxx•2026Varies175h (Medium)

Currently, Mixxx uses PortAudio as a high level abstraction over audio APIs across all supported platforms, which only exposes the common subset of all those APIs, missing Linux specific features and conventions. This implementation will add Pipewire audio API support to Mixxx for Linux, listen for PipeWire events to support soundcard hotplug and update routing UI according to changes made in an external patchbay. It will also allow Mixxx to route audio to and from any source/sink. This proposal also attempts to achieve ALSA comparable latency with the PipeWire backend.

javascriptc++qt+3
Student: Priyanshuwu
Code
Proposal

OWHF: Enhancing Indian Holidays: National and Subdivision Accuracy with Comprehensive Localization

intermediate
Python Software Foundation•2026Varies175h (Medium)

This project aims to improve the accuracy, completeness, and accessibility of Indian holidays in the Open World Holidays Framework (OWHF). It focuses on verifying and updating national and subdivision-level holidays using official government sources, ensuring consistency across all 28 states and 8 union territories. In addition, the project will expand localization support by providing holiday names in widely used Indian languages, making the framework more accessible to a broader user base. To enhance long-term consistency and maintainability of calendar-based holidays, the project will also introduce generator scripts for solar and lunisolar holidays. These scripts will be used to generate and validate holiday dates across extended year ranges, while keeping the runtime implementation lightweight and dependency-free. The final outcome will be a more accurate, fully localized, and scalable holiday dataset for India, aligned with real-world usage and the design principles of the holidays framework.

pythonmercurialjavascript+3
Student: ankushhKapoor
Code

Evaluating Cloud-Native Storage: Performance Benchmarking for Uyuni on RKE2

advanced
openSUSE Project•2026Varies350h (Large)

I propose to build a reproducible benchmark framework for evaluating cloud-native storage options for Uyuni on RKE2. The problem is that different Kubernetes storage backends can behave very differently for the kinds of operations Uyuni depends on, especially PostgreSQL transactions, repository metadata handling, and package distribution. The project will address this by starting from a storage-only control baseline and then extending the evaluation into PostgreSQL benchmarking and Uyuni-specific workload benchmarking, while collecting synchronized observability data for each run. The same benchmark method will be reused across selected storage backends so that results remain comparable and can support a practical recommendation for which StorageClass Uyuni should support on RKE2. The main deliverables will be a reusable benchmark harness, benchmark results for the tested storage backends, PostgreSQL and Uyuni workload comparison data, observability-backed summaries, and a final report that explains the benchmark method, compares the backends, and recommends the most suitable StorageClass. The project will also produce the configuration artifacts and scripts needed to rerun the benchmark process and reproduce the tested setup.

pythonlinuxjavascript+11
Student: AkashKumar
Code

Compile-time Specialization for Scala 3 via Inline Traits

advanced
Typelevel•2026Varies350h (Large)

Specialization is a compiler transformation that optimizes generic program code such that code using primitive types can execute without significant overhead. The @specialized annotation in the Scala 2 programming language allowed programmers to direct the compiler to create optimized generic data structures for each primitive type. @specialized is used significantly in the implementation of high-performance Scala 2 libraries, allowing for performance without the productivity of generics. This optimization trades performance at the cost of extra space, as generic code must be specialized for each of the primitive types, scaling exponentially on the number of type parameters. Since the Scala 3 programming language has evolved significantly from Scala 2, the @specialized annotation is no longer available. This proposal will prototype a new scheme of specialization for the Scala 3 compiler based on inline traits that avoids the performance pitfalls of the Scala 2 implementation, enabling the evolution of many high-performance Scala 2 libraries into Scala 3.

linuxnode.jsjvm+2
Student: James You
Code
Proposal

Succinct Data Structure for Efficient Operations on Trees in Scikit-bio

advanced
NumFOCUS•2026Varies350h (Large)

Scikit-bio offers a great toolkit for working with biological data that has a tree-like structure. Although the current implementation, TreeNode, can accommodate a large variety of use-cases, its pointer-based nature limits its scalability to large trees with billions or even trillions of nodes. This project aims to remedy this problem by implementing a succinct data structure for trees based on its balanced parentheses representation, such that the memory usage and the time required for operations are minimized. There are two main components to this project. The first component pertains to the implementation of the data structure proposed in using Numba and NumPy based on improved-octo-waddle, a previous implementation using Cython. The other component relates to integrating the new data structure into the back-end of the existing TreeNode class within the library to enable compatibility with the existing APIs. The core deliverables include: an implementation of the new data structure that can be interfaced via TreeNode, an extensive suite of tests for correctness and benchmarking to ensure performance uplifts, and documentation to guide users on the usage of the new data structure. As a potential extension, GPU support will be investigated along with the exploration of an alternative solution proposed by Córdova, J. and Navarro, G. (2016).

pythonjavascriptr+3
Student: Timothy Wong
Code

Compile M_intrinsics, fman, and gtk-fortran packages with LFortran

advanced
Fortran-lang•2026Varies350h (Large)

This proposal aims to improve LFortran by compiling and validating real-world Fortran packages such as M_intrinsics, fman, and gtk-fortran. Instead of focusing on isolated features, it follows a compilation-driven approach to identify and resolve limitations across different stages of the compiler, including parsing, semantic analysis, code generation, and runtime support. Key issues such as incomplete I/O specifier handling, quadruple precision support, and array constructor transformations will be addressed. The project emphasizes iterative development, testing, and validation against reference compilers, with the goal of improving LFortran’s robustness, correctness, and support for complex, real-world applications.

pythonc/c++llvm+3
Student: HarshilShah
Code
Proposal

Build a GUI Agent with Local LLM/VLM using OpenVINO for Desktop Automation

intermediate
OpenVINO Toolkit•2026Varies175h (Medium)

A lot of everyday computer tasks—like navigating applications, managing files, and configuring settings—are repetitive and require multiple manual steps. Existing automation solutions rely on brittle scripts or cloud-based AI systems, which introduce latency, privacy concerns, and limited adaptability. This project aims to build a native desktop GUI agent that can understand natural language instructions and autonomously operate the computer interface. The system will combine Vision-Language Models (VLMs) for screen understanding and Large Language Models (LLMs) for reasoning and task planning, all running locally using OpenVINO for efficient, low-latency inference. The proposed solution uses a multi-agent architecture consisting of a Router, Planning, UI Grounding, Action Execution, and Reflection agents. The VLM (Phi-3.5 Vision) will interpret screenshots and map UI elements to coordinates, while the LLM (DeepSeek-R1 Distill Qwen 7B) will decompose tasks and generate action sequences. A PyQt-based desktop interface will allow users to interact with the agent, monitor execution, and configure settings.

pythonc++x86+1
Student: Shehroz Kashif
Code

SimNIBS TMS Electric Field Simulation and Head Modeling Integration in InVesalius

intermediate
Invesalius•2026Varies175h (Medium)

Implementation of a direct integration between SimNIBS and InVesalius to enable subject-specific head model generation and TMS electric field (E-field) simulations within InVesalius. Currently, head modeling and E-field simulations require external workflows and manual data handling. This project will integrate the full pipeline into InVesalius, allowing users to generate MRI-based head models, position and orient TMS coils using existing neuronavigation tools, configure simulation parameters, execute simulations internally, and visualize E-field magnitude (|E|) directly on 3D anatomical models. The activity will focus on implementing a Python-based interface to SimNIBS, aligning coordinate systems, handling simulation inputs/outputs robustly, and integrating results into the InVesalius visualization environment. Deliverables: Integrated MRI-based head modeling pipeline. Python interface module connecting InVesalius to SimNIBS. UI panel for head modeling and simulation configuration. Execution of TMS E-field simulations within InVesalius. 3D visualization of E-field magnitude (|E|). Technical documentation.

pythoncythonnumpy+2
Student: Yiqi
Code

Apache Airflow Contribution & Verification Agent Skills

advanced
Apache Software Foundation•2026Varies350h (Large)

This project improves AI agent reliability in Apache Airflow by addressing long-context degradation in realistic multi-turn development sessions. I will build auto-synced SKILL.md artifacts from Airflow’s contributor docs to prevent context drift, a community workflow for collecting and triaging real agent failure cases, and an Airflow-specific benchmark for evaluating workflow compliance on real tasks. The final deliverables include CI-backed skill generation, failure-case aggregation, benchmark scenarios with scoring, and a modular skills folder that reduces context pressure by loading only task-relevant guidance.

pythonjavascriptjava+7
Student: Jhe Chen Li
Code
Proposal

Apache Fory C++ & Rust gRPC Integration

advanced
Apache Software Foundation•2026Varies350h (Large)

Apache Fory provides high-performance serialization & deserialization and code generation from IDL, but it currently lacks end-to-end gRPC service integration for C++ and Rust. As a result, developers may still need to rely on external toolchains (e.g. protoc/prost) to generate service bindings, which prevents Apache Fory from being used as a complete gRPC solution. This proposal aims to enable Apache Fory to generate gRPC-compatible client and server code for both C++ and Rust, while reusing the existing gRPC runtimes (gRPC C++ and tonic). The core idea is to extend the Apache Fory compiler to generate service stubs and integrate Fory's serialization & deserialization into the gRPC pipeline by replacing the default codec (protoc and prost). The design decouples API definitions from transport- layer bindings and introduces reusable codec implementations. The project will also include comprehensive testing (unit, differential, and cross-language), CI integration, and documentation. This work will make Apache Fory a practical alternative to existing protobuf-based toolchains in gRPC frameworks and provide a reference architecture for adding gRPC support to other languages in the future.

pythonjavascriptjava+7
Student: Peiyang He
Code
Proposal

Cross-Platform SCM Support for Scrum Helper

intermediate
FOSSASIA•2026Varies175h (Medium)

Scrum Helper currently supports only GitHub and a partially-integrated GitLab, with all platform logic tightly coupled in a 2,190-line monolithic file. This makes adding new SCM platforms nearly impossible without duplicating the entire data-fetching flow. This project refactors Scrum Helper's core into an extensible Provider Pattern architecture by defining a standardized SCMProvider interface that decouples platform-specific API calls from the report generation engine. I will then implement native providers for GitLab (including self-hosted instances), Gitea, and Bitbucket, each returning normalized data through a unified schema. Deliverables: (1) SCMProvider interface with normalized data models, (2) Refactored GitHubProvider with full regression coverage, (3) GitLabProvider with self-hosted baseUrl support, (4) GiteaProvider tested against Codeberg, (5) BitbucketProvider with OAuth 2.0 auth, (6) unified caching and cross-provider error handling, and (7) architecture guide and contributor docs for adding future providers. All 4 platforms will generate identical scrum reports by project end.

pythonjavascriptandroid+7
Student: Kaung Hset Hein
Code
Proposal

Liquid Galaxy: Ubuntu LTS System Migration - Ubuntu 16.04 to Ubuntu 24.04

intermediate
Liquid Galaxy project•2026Varies175h (Medium)

Liquid Galaxy is an open-source panoramic multi-display system used in museums, universities, and science centers worldwide. Its entire installation infrastructure install.sh and all supporting configuration files was written for Ubuntu 16.04 LTS, which reached End of Life in April 2021. As a result, Liquid Galaxy cannot be installed on any currently supported Ubuntu version, leaving existing deployments without security patches and blocking new ones entirely. This project is a systematic, layer-by-layer migration of Liquid Galaxy to Ubuntu 24.04 LTS (Noble Numbat). Rather than patching each broken line individually, I will introduce an OS abstraction layer a lib/ directory of functions that encapsulate every OS-dependent operation, from network detection and display manager configuration to package management and service control. This ensures the system can survive future Ubuntu LTS releases without requiring a full rewrite each time. Deliverables: 1) Updated install.sh working end-to-end on Ubuntu 24.04 2) lib/ OS abstraction layer with testable, version-aware functions 3) GitHub Actions CI pipeline 4) Post-install smoke test suite 5) MIGRATION.md, TROUBLESHOOTING.md, and updated README.md with complete architecture documentation.

javascriptrosgis+14
Student: Mahmoud Mohammed
Code

Extending C++ Support in GCC Static Analyzer

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

GCC's static analyzer (-fanalyzer) lacks C++ class hierarchy awareness, causing it to miss bugs in exception catch blocks that use base types and limiting virtual function resolution. This project implements exception subclass matching (PR119697) and improves virtual function dispatch (PR97114) by adding type hierarchy infrastructure to the analyzer.

cc++openmp+3
Student: Egas Ribeiro
Code
Proposal

AI/ML to Enhance and Streamline Manual/TA Grading

intermediate
Submitty•2026Varies175h (Medium)

This project develops an intelligent clustering system that groups student submissions by similar patterns, algorithmic approaches, and correctness levels. The system enables TAs to efficiently manage large-scale grading while maintaining fairness and consistency. Problem: TAs face repetitive, time-consuming grading of similar submissions with risk of inconsistency and human error, especially in large courses (100+ students). Solution: Automated clustering of submissions using hierarchical agglomerative clustering with interactive dendrogram visualization. TAs can merge/split/reject clusters, bulk apply feedback templates, and flexibly grade (bulk or individual). Key Deliverables: - Feature extraction engine (68-dim for code, 389-dim for text) - Hierarchical clustering with Ward linkage - Interactive dendrogram UI for TA manipulation - Bulk feedback application system with per-student customization - Flexible grading modes (bulk, individual, hybrid) - Comprehensive testing and documentation Expected Impact: 80-90% reduction in grading time while improving consistency and feedback quality. Time savings: 45 submissions graded in 15 minutes vs 225 minutes without clustering.

pythonc++databases+5
Student: GarvitKhandelwal
Code
Proposal

Quantum Circuit Design with LLMs

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

Variational quantum circuits are essential for near term quantum algorithms but designing them involves complex manual trial and error. This project solves this bottleneck by creating an automated agentic framework using Large Language Models to synthesize and optimize quantum circuits. By interacting with quantum simulators in a closed loop the AI agent will debug circuits and minimize gate depth automatically. The main deliverables include custom Orchestral AI tools for quantum simulators an iterative feedback pipeline for hyperparameter tuning and comprehensive benchmarking to uncover novel gate sequences.

pythonmachine learningc+++2
Student: Tomoya Hatanaka
Code
Proposal

Agentic Cognitive Firewall SDK

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

LLM agents built with LangGraph and LangChain retrieve documents, call tools, and write to memory - but nothing validates what enters the model's context. A poisoned RAG document can hijack an agent's behaviour. A malicious tool parameter can exfiltrate data. A single memory write can silently alter every future response. There's no standard security layer for any of this. ACF-SDK is a Zero Trust firewall that sits between the agent and the LLM - intercepting every input across four hooks (prompt, context, tool call, memory) and enforcing policy-as-code decisions through an isolated Go sidecar. I want to take this pipeline from hardcoded ALLOW to real enforcement: upgrade the semantic scanner to catch paraphrased attacks, wire scanner signals into the real sidecar, build memory write protection with HMAC and provenance tracking, ship a Docker demo anyone can clone and run in 5 minutes, and stress-test the whole system against adversarial evasion techniques with a technical evaluation report. The foundation is already built. I've shipped 6 PRs - semantic scanner, benchmark harness, LangGraph adapter, Rego policy templates for all four hooks, audit logger, and a Go scan stage implementation. 155 tests passing. GSoC wires these components into a running system and proves they hold up under real attacks.

pythonjavago+2
Student: Pranjal Udhwani
Code
Proposal

Native RoaringBitmap Integration for Apache Fluss

advanced
Apache Software Foundation•2026Varies350h (Large)

Apache Fluss contains dormant RoaringBitmap aggregation infrastructure but the BITMAP type is trapped in UnsupportedKeyword making it inaccessible to users. This project promotes BITMAP to a first-class logical type wires it to the existing AggregationMergeEngine and implements five SQL functions via FlussCatalog. The centrepiece is a pushdown optimization in FlinkTableSource.applyAggregates() that intercepts BITMAP_OR_AGG queries and redirects them to the TabletServer native merge engine reducing network cost from O(N) to O(G). A working prototype with 4 passing unit tests is already available. Deliverables include type system bridge server-side wiring Flink connector pushdown integration tests performance benchmarks and a quickstart guide.

pythonjavascriptjava+7
Student: Prajwal Banakar
Code

VLC watchOS port: Audio Player

intermediate
VideoLAN•2026Varies175h (Medium)

The goal of this project is to bring VLC’s media playing capabilities to watchOS using the newly added support from VLCKit. The watchOS app will be able to play audio files locally as a standalone app as well as sync with the iOS app to act as a remote for controlling audio playback.

copenglc+++10
Student: Timmy Nguyen
Code
Proposal

OrgExplorer GitHub Organization Analytics Dashboard

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

When I first tried exploring open-source organizations on GitHub, I kept running into the same problem. GitHub shows great details for each repository, but almost nothing that helps you understand an organization as a whole. I had to open repo after repo just to figure out which projects were active, which languages were common, and who was actually contributing. It felt slow, manual, and frustrating. That experience led me to build OrgExplorer. OrgExplorer is a fully client-side web app that turns raw data from the GitHub REST API into clear, organization-level insights. There’s no backend, no login, and no setup. You simply enter one or more organization names and, within seconds, you can see language distribution, repository health, contributor coverage, governance risks, and activity trends. Everything is cached locally so the app feels fast and doesn’t waste API requests. Behind the scenes, OrgExplorer merges repositories and contributors from multiple organizations into a single data model. From that, it highlights practical signals like bus factor risk, cross-repo contributor coverage, dead issues, zombie pull requests, and how activity changes over time. By the end of GSoC, OrgExplorer will support multi-organization analysis, an interactive contributor–repository network graph, repository health classification, governance audits, activity trend charts, exportable reports, deep-linked views, and offline support as a Progressive Web App. Smart caching ensures it stays within GitHub’s rate limits, with optional token support for larger explorations.

pythonjavascriptswift+8
Student: Ritik Roshan Yadav
Code
Proposal

Implementing App Uninstallation in the GNOME Shell App Grid

beginner
GNOME Foundation•2026Varies90h (Small)

This proposal aims to add a simple built in way to uninstall applications directly from the GNOME shell App Grid Right now users have to open the GNOME software app or use the terminal just to delete a application. This project solves that by adding an "Uninstall" option straight into the app's right click menu. When a user clicks it, the system will quietly tell GNOME software to remove the app in the background. To show the user that it is working, the app's icon will fade slightly and then disappear completely once the uninstallation finished. By cutting out extra steps and keeping users in their normal workflow, this feature will make managing apps much faster. This will promise to smooth out a very common task and noticeably improve the daily experience for anyone using GNOME desktop

cpythonjavascript+4
Student: Shyam Jagath
Code
Proposal

CEP 59 Graceful Disconnect for Apache Cassandra

intermediate
Apache Software Foundation•2026Varies175h (Medium)

When a Cassandra node shuts down, clients experience timeout errors because drivers cannot distinguish planned shutdown from a crash. CEP-59 introduces a GRACEFUL_DISCONNECT event in the native binary protocol that lets the server signal drivers before closing connections. My implementation uses a self-draining mechanism that hooks into the existing cleanup() callback in CQLMessageHandler — each connection closes itself when its last response flushes out, after a grace period that accounts for network-latent requests. Three conditions added to an existing callback, no new threads or timers. Deliverables: server-side four-phase shutdown (SEAL, SIGNAL, DRAIN, DEADLINE), Python driver support with DRAINING host state, configuration and observability metrics, protocol spec update, and unit/integration tests. Java driver support as a stretch goal. JIRA: CASSANDRA-21265 (7 sub-tasks).

pythonjavascriptjava+7
Student: Shanzita siddiqua
Code
Proposal

Adding New Similarity Metrics for DIPY’s Image Registration Frameworks

intermediate
Python Software Foundation•2026Varies175h (Medium)

This proposal aims to extend DIPY's image registration framework by implementing new similarity metrics, with a particular focus on Mutual Information (MI) for nonrigid registration. While MI is currently available in DIPY for affine registration, support for nonrigid registration is not yet implemented despite its importance for multimodal medical imaging. This project will design, implement, and integrate an efficient MI-based similarity metric within DIPY's existing registration pipeline, together with appropriate validation and testing.

pythonmercurialjavascript+3
Student: TomasGuija
Code
Proposal
Showing 97 - 120 of 11996 Projects
34567
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal