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

Batch Prediction Framework: Long Context and Context Caching for Video Analysis

advanced
Google DeepMind•2025Varies

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 an efficient framework for analyzing educational video content using the Gemini API. The approach combines optimized batch prediction, intelligent context caching, and conversational memory to reduce API usage significantly while improving coherence in multimodal interactions. The framework addresses common challenges when analyzing video content: redundant API calls, context fragmentation with long transcripts, and lack of conversational coherence across related questions. Key deliverables include a modular architecture implementing efficient batch processing with dependency analysis, adaptive context caching strategies for transcripts of varying lengths, conversation memory management for follow-up questions, and structured response formatting with timestamp references. The solution aims to achieve a 4-5× reduction in API calls while maintaining high-quality responses, serving as both a practical tool and a reference implementation demonstrating Gemini API best practices.

pythonjavascripttypescript+2
Student: Sean Brar
Code
Proposal

Enhancing the spinebil Package for Projection Pursuit Diagnostics

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

The spinebil package provides diagnostic tools to evaluate projection pursuit (PP) index functions, which are used to discover informative low-dimensional projections of high-dimensional data. However, current tools for understanding the behavior of these indices under varying data conditions are limited. This project aims to enhance spinebil by developing diagnostics that assess how PP indices behave under noise, structure, varying sample sizes, and scale interpretation. I will implement routines to test index performance across noise-to-structure transitions, evaluate index value ranges, analyze sample size sensitivity, and apply these diagnostics to both existing and scagnostic-based indices (e.g., stringy, skinny). I will also optimize the code for performance and clarity, write detailed documentation and a vignette, and design a hex sticker for the package to support its identity on CRAN. This project will support the development of more robust, interpretable projection pursuit indices and make spinebil more accessible to researchers, educators, and developers.

cc++r+4
Student: Tina.rj
Code

Akonadi resources - Remove QtWidgets dependency

advanced
KDE Community•2025$6k–$13.2k350h (Large)

The primary goal of this project is to refactor Akonadi’s agents and resources by decoupling their configuration dialogs from their underlying logic. This change will allow us to remove the inclusion of heavy QtWidgets header files, which currently lead to unnecessary memory usage. Reducing this overhead is essential for making the Merkuro suite fully usable on mobile devices, where resource constraints are critical. At present, many components load their GUI elements by default, unnecessarily increasing the memory footprint and hindering performance on resource-constrained platforms. By refactoring these configuration dialogs into separate, dynamically loaded plugins, the agents and resources can run leaner and more efficiently (it would save around 15-20 Mib of RAM per agent/resource) while still providing full-featured configuration interfaces when needed by host applications. Project Deliverables ● Refactor as many as reasonably possible of the selected Akonadi agents and resources within the GSoC timeframe. The goal is not necessarily to port all agents, but to make meaningful progress and establish a repeatable pattern for others to follow, ensuring the project is successful even if not every target is completed. ● Eliminate embedded QtWidgets dependencies—such as replacing QApplication with QCoreApplication—in their primary functionality. ● Identify and replace additional usages of QtWidgets beyond the configuration dialogs—such as QMessageBox instances used to show error messages. ● Modify build configurations (CMake files) to strip out unnecessary UI files and reduce dependencies, thereby lowering memory usage. ● Create dedicated configuration plugins that encapsulate the GUI functionality previously embedded within agents and resources. ● Test and document all changes to verify that memory usage is indeed reduced and that the new plugin-based configuration system functions correctly across both desktop and mobile environments.

c/c++qtqml+6
Student: Pabarino
Code
Proposal

Implementing the Bandwidth Algorithm for pgRouting

advanced
OSGeo (Open Source Geospatial Foundation)•2025Varies350h (Large)

This project intends to port the Boost Graph Library's 'Bandwidth' algorithm for pgRouting into OSGeo. Graph bandwidth is a primitive parameter in graph theory that measures the largest distance between adjacent vertices when placed in a linear manner. In the context of pgRouting and spatial databases, calculation of graph bandwidth can optimize routing algorithms and query performance on huge road networks. The implementation will comprise: Building pgr_bandwidth() function with SQL interface C++ backend utilizing Boost Graph Library Integration with current pgRouting algorithms (especially Cuthill-McKee ordering) Thorough documentation and examples Unit testing using pgTap The algorithm will assist users in examining structural features of road networks, locating bottlenecks, and database operation optimization using enhanced cache locality and query execution. This project fills the gap of existing pgRouting capabilities by providing another valuable graph metric utility for network topology examination. The deployment will adhere to pgRouting's coding guidelines and will be thoroughly tested against diverse datasets such as pgRouting sample data, benchmark graphs, and real-world transport networks.RetryClaude may err. Kindly double-check responses.

pythonjavascriptc/c+++4
Student: Saloni Kumari
Code

Introduce an ABI lowering library

intermediate
LLVM Compiler Infrastructure•2025Varies175h (Medium)

The current implementations of the LLVM Project, have a drawback that every language frontend that wants to support Foreign Function Interface(FFI) into C code needs to implement Application Binary Interface(ABI) handling logic by itself. This leads to tremendous duplication of efforts and leaves the chance of potential inconsistencies. The aim of this project is to create a comprehensive ABI library housed within LLVM which would encapsulate the details of various platform specific calling conventions, argument passing strategies and return value handling.

cllvmc+++3
Student: Narayan Sreekumar
Code
Proposal

Whiteboard Improvements

advanced
Jitsi•2025Varies350h (Large)

Jitsi Meet’s current whiteboard—built on an outdated Excalidraw fork and Socket.IO v2.5—only supports basic “smart objects,” lacks file/image upload, and suffers from performance and maintenance challenges. This project will: Upgrade real‑time transport by moving to Socket.IO 4.x and optimizing WebSocket message flow (batching, compression) for lower latency. Migrate to the latest Excalidraw release, ensuring full compatibility with Jitsi Meet and access to new drawing features. Implement a pluggable storage backend (starting with MiniIO) so users can share files directly on the whiteboard. Deliverables: -A collaboration server upgraded to Socket.IO 4.x with measurable performance gains -An updated Jitsi whiteboard using the newest Excalidraw version -A modular storageBackend abstraction plus working MiniIO module

javascriptjavaxmpp+5
Student: Yash Gussian
Code
Proposal

Natural Language Bridge to Legacy Email

beginner
rocket.chat•2025Varies90h (Small)

The Natural Language Bridge to Legacy Email project represents a groundbreaking solution to one of modern communication's most persistent challenges: The continued widespread use of legacy email alongside newer messaging platforms. Despite the evolution of systems like Rocket.Chat, email remains deeply entrenched in global workflows and communities. This project elegantly bridges this divide by creating a seamless interface that allows Rocket.Chat users to interact with email systems through natural language commands, bringing legacy email functionality directly into the Rocket.Chat environment. By leveraging advanced LLM capabilities, this integration will allow users to perform complex email operations without leaving their Rocket.Chat conversations. The app responds to natural language instructions, enabling email tasks to be completed with simple, intuitive commands that feel like conversational requests.

javascriptwebrtcmeteor.js+18
Student: Priyanshu Harshbodhi
Code
Proposal

VLC macOS Modern Interface Redesign

advanced
VideoLAN•2025Varies350h (Large)

Problem: VLC’s macOS interface has fallen behind modern design standards, creating a disjointed experience compared to its intuitive iOS/tvOS counterparts. The current AppKit-based UI lacks macOS Sequoia's visual polish, struggles with libvlc’s newer playback features (e.g., frame-accurate seeking), and suffers from inefficient media library management. This outdated design hinders usability and fails to make use of macOS’s native capabilities. Solution: Redesign VLC’s macOS interface using AppKit to implement a pre-approved, user-tested design that integrates into macOS visual aesthetics and libvlc’s advanced APIs. The overhaul will: 1. Replace legacy Carbon-era UI components with modern NSCollectionView and NSSplitViewController layouts. 2. Integrate libvlc’s latest playback controls (frame stepping, HDR metadata) into native transport UIs. 3. Rebuild the media library using Core Data for performance and NSDiffableDataSource for real-time updates. 4. Prioritize system consistency with SF Symbols, vibrant materials, and macOS accessibility standards. Deliverables: 1. Modern UI Components: - Unified toolbar with adaptive controls (NSToolbarItemGroup) - Redesigned media library with thumbnail grid (NSCollectionView) and smart filters (NSPredicateEditor) 2. Enhanced Playback: - Frame-accurate seekbar with NSSlider tick marks synced to libvlc’s next_frame() API - HDR tone mapping toggle using CAMetalLayer integration 3. Optimized Media Management: - Rules-based playlists backed by Core Data - Spotlight-like search using NSFetchRequest 4. Developer Documentation: - Migration guide for plugin developers - NSAccessibility implementation notes By collaborating closely with VLC’s core team and iterating on the existing codebase, this project will deliver a performant, native macOS experience that bridges the gap between VLC’s powerful engine and modern user expectations.

copenglc+++10
Student: Bob Moriasi
Code
Proposal

Decorator Command Set JSON <-> YAML Converter

beginner
Accord Project•2025Varies90h (Small)

The goal of this project is to enhance the usability of Decorator Command Set (DCS) data by developing a utility/method to convert verbose, complex JSON formats into a more human readable YAML representation and back again. Currently, it is highly verbose to read, write, and edit DCS JSON files. The plan is to implement a converter that turns DCS JSON objects into a simple YAML format and back again. The new YAML will be less verbose and more readable, helping people work with DCS better. By the end, a fully integrated converter will be delivered, complete with tests and proper documentation.

javascriptreactcompiler+5
Student: Asmit Phuyal
Code
Proposal

OpenVINO GenAI provider for LangChain

advanced
OpenVINO Toolkit•2025Varies350h (Large)

This project aims to develop an OpenVINO GenAI extension for LangChain, enabling users to utilize OpenVINO as a backend for running language models. It involves integrating these components to ensure seamless compatibility, providing optimized performance for language model inference. Deliverables: 1. A fully functional OpenVINO GenAI extension for LangChain, allowing users to run language models with OpenVINO as the backend. 2. A finalized package distributed as a Python wheel.

pythonc++x86+1
Student: bhuminjaysoni
Code
Proposal

Adding Kani proofs for Virtqueues in Rust-vmm

intermediate
QEMU•2025Varies175h (Medium)

This project aims to formally verify that the Rust vmm (a Rust implementation of the VirtIO specification used in virtualization platforms like QEMU) behaves correctly according to the VirtIO specification. The approach involves writing unit proofs for critical functions in Rust vmm and verifying them using Kani, a Rust-based bounded model checker. These proofs, which will be integrated into continuous integration (CI), will not only check correctness for all executions within a bound but also verify memory safety, especially in areas mixing safe and unsafe Rust. Community Benefits: 1. Increased trust in Rust vmm’s conformance to the VirtIO spec, benefiting all dependent projects. 2. Maintainable proofs using the Code-As-Spec paradigm, making them accessible to Rust vmm developers. 3. Demonstrates the practical value of formal verification for ensuring correctness in critical open source infrastructure.

cassemblykvm+4
Student: Siddharth Priya
Code
Proposal

Conda packaging for GeNN

intermediate
INCF•2025Varies175h (Medium)

GeNN is a C++ library that generates code for efficiently simulating Spiking Neural Networks (SNNs) using GPUs. In order to compile this generated code, it requires a compiler and development versions of backend requirements such as CUDA. Because of this, GeNN must currently be installed from source which puts off some users. So for this project, I aim to develop a conda (forge) package for GeNN which will handle the installation of the required dependencies and ease installation for end users. Deliverables: -Conda Forge Recipe -User Documentation

pythonjavac+++7
Student: Agrim Patil
Code
Proposal

Math Games

intermediate
Sugar Labs•2025$3k–$6.6k175h (Medium)

I plan to develop 10 Math games for Sugar within the GSoC’25 timeline. The development of these activities will include basic functionalities of the game in addition to other features which are not mentioned particularly like Sound and themes and sugar features like journals (to keep the changes saved for game resume features), user color schemes, toolbar, etc

pythonjavascriptgtk++10
Student: Bishoy Wadea
Code
Proposal

Metro-MPI++

intermediate
Free and Open Source Silicon Foundation•2025Varies175h (Medium)

Modern RTL simulation is computationally expensive and often limited by single-node processing capabilities. This proposal aims to improve Metro-MPI++, a tool for distributed RTL simulation using Verilator and MPI, to better handle large-scale designs like OpenPiton. The project focuses on automating tile and interconnect detection in OpenPiton, optimizing MPI-based simulation interfaces, integrating hybrid parallelism with OpenMP, and laying the groundwork for FPGA backend support. The deliverables include a scalable partitioning framework, enhancements to the simulation runtime, example simulations demonstrating speedup, and contributions to Verilator’s partitioning features. These improvements will make RTL simulation more scalable, accessible, and efficient for open-source hardware projects.

pythonjavascriptfpga+11
Student: Kislay Arya
Code
Proposal

BugSim(Bug Simulator and Learning)

advanced
OWASP Foundation•2025Varies350h (Large)

BugSim (Bug Simulator and Learning) is an advanced bug simulation platform integrated into OWASP BLT. It helps security researchers, ethical hackers, and developers understand, simulate, and resolve vulnerabilities in real-world environments. The project includes features like: Hands-on bug simulation and learning with various vulnerability categories (SQL Injection, XSS, CSRF, etc.). Weekly vulnerability challenges and structured bug reporting. Integration with OWASP ZAP for automated security testing. Live hackathons and competitive bug hunting with leaderboards. Gamification with points, badges, and rewards. This project will enhance OWASP BLT by creating an engaging and interactive cybersecurity learning platform. The deliverables include a fully functional BugSim module, complete with vulnerability simulations, a scoring system, and real-time security reporting.

pythonjavascriptjava+10
Student: Lucky Negi
Code
Proposal

Perspective

intermediate
AOSSIE•2025Varies175h (Medium)

Perspective addresses the problem of biased and one-sided narratives in online articles by providing readers with a fact-based, well-structured alternative perspective. The solution involves a pipeline that scrapes article content, processes and cleans the text, extracts key points, and generates a logical counter-perspective using LangGraph and LangChain. The system will include a frontend for user interaction, an AI-driven backend for perspective generation, and a vector database for storing results. Deliverables: - A fully functional web application where users can input article URLs. - AI-powered alternative perspective generation based on extracted key points. - Fact-checking mechanisms using reliable sources. - Vector database storage for efficient retrieval and chat-based exploration.

pythonjavascriptswift+8
Student: Parag Ghatage
Code
Proposal

Project 12: Empowering Kubeflow Documentation with LLMs

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

refer notion site for better view : https://smart-rhubarb-c5c.notion.site/GSoC-2025-Proposal-Project-12-Empowering-Kubeflow-Documentation-with-LLMs-1c209ac9a7bd80e6941ee51ab6601c7c This project aims to build an AI-powered assistant for the Kubeflow ecosystem using Retrieval-Augmented Generation (RAG) and a long-context LLM. The assistant will index Kubeflow Github repository including, GitHub issues, and community discussions using a structured pipeline involving Feast (feature store) and Milvus (vector DB). It will support real-time queries through a FastAPI WebSocket interface and serve responses via KServe. Key deliverables include: End-to-end RAG pipeline integrated with Kubeflow Pipelines & Feast GitHub-triggered document ingestion and vector index updates LLM deployment and retrieval API with RBAC controls Evaluation loop using “LLM-as-a-Judge” Monitoring setup with Prometheus + Grafana Frontend integration with Hugo-based docs site This project will improve Kubeflow’s developer experience by enabling contextual, cited answers directly from its ecosystem.

pythontensorflowkubernetes+5
Student: Santhosh Toorpu
Code
Proposal

Project 10: Support Volcano Scheduler in Kubeflow Trainer

advanced
Kubeflow•2025Varies350h (Large)

This document outlines a proposal to support Volcano for gang-scheduling in Kubeflow Trainer, so as to provide users with more AI-specific scheduling capacities like priority scheduling and queue resource management. This will allow for better control over resources, with features like queue management and job prioritization. Thanks to the Kubeflow Trainer Pipeline Framework, we can seamlessly integrate Volcano into Kubeflow Trainer as a runtime plugin. The deliverables include: 1. The integration of the Volcano plugin into the Trainer, allowing for Gang-Scheduling and resource management. 2. Documentation updates, including usage examples and design details. 3. Testing the plugin's functionality and performance under various environments.

pythontensorflowkubernetes+5
Student: Xinmin Du
Code
Proposal

BrainGlobe: Automating Region Selection in brainglobe-registration

advanced
Neuroinformatics Unit•2025Varies350h (Large)

Synopsis: This project aims to enhance the brainglobe-registration tool by automating the selection of atlas regions for aligning 2D or 3D brain images to a standard anatomical reference via brainglobe-atlasapi. Currently, this process is manual, time-consuming, and subjective, posing a barrier to reproducibility and efficiency. By introducing a new preprocessing step that automatically identifies the optimal atlas region – using methods such as adaptive grid search, machine learning, or Bayesian optimisation – this project will streamline the workflow and improve accuracy. Deliverables include at least two implemented approaches, benchmarking, comprehensive testing, full documentation, and a blog post to showcase the new functionality. This automation directly benefits my research in paediatric radiotherapy, where mapping histology images to an atlas is essential for analysing cellular behaviour across brain regions. By making this process faster and more robust, it not only enhances my own work but also enables broader adoption of BrainGlobe tools by researchers in neuroscience and healthcare, even those without extensive anatomical expertise. Minimal Set of Deliverables: • Implement a new preprocessing step to automatically select the atlas region. • Compare at least two region-selection methods (e.g., adaptive grid search vs ML/Bayesian optimisation). • Add tests to validate the new functionality. • Document the new pipeline and add usage instructions. • Write a blog post showcasing the project and results.

pythonnumpypytorch+2
Student: Saarah Hussain
Code

OWTF MiTM Proxy Modernization

intermediate
OWASP Foundation•2025Varies175h (Medium)

OWTF's built-in MiTM proxy was developed nearly a decade ago and is currently outdated, limited in functionality, and hard to maintain. This project aims to completely modernize the MiTM proxy component to make it as feature-rich, stable, and flexible as modern alternatives like mitmproxy. The upgraded proxy will support TLS interception, live modification of HTTP(S) requests and responses, robust transaction logging, and seamless integration with the OWTF framework and frontend. Deliverables include a fully functional, test-covered modern proxy component with improved logging, dynamic tampering support, and compatibility with OWTF's plugin and reporting infrastructure.

pythonjavascriptjava+10
Student: Naveen Prakaasham Vairaprakasam
Code
Proposal

Ilastik: Support For Image And Video Analysis With Real-World Units

intermediate
Python Software Foundation•2025Varies175h (Medium)

The project involves integrating pixel size support into ilastik, an image-processing and classification tool. Pixel size is a metadata item enabling conversion of image pixels into real-world measurements. Whilst pixel size is not currently processed in ilastik image sets, the program is used extensively in scientific applications, and introducing real-world measurements would enable development of several key features that would allow more in-depth quantitative analysis of image data, such as object displacement and velocity in video tracking, and real-world area calculation of segmentations/ volume calculation of carvings. Once the metadata is extracted at the image input end, it is possible to feed it directly into the data pipeline, so it can be picked back up within any relevant workflow. This facilitates feature development, as it then becomes possible to work directly with the metadata values within the workflow. Once the backends of these features have been developed, they will be implemented on the front-end via Qt. The key deliverables of this project are: Implement pixel size metadata into workflows, such that the metadata remains present in project files, output images, and exported datasets; Enable calculating areas of image segmentations; Enable calculating volumes of image carvings; Enable recording of object displacement in video tracking; Enable measurement of object velocity in video tracking; Produce detailed and well-written documentation, and ensure relevant test scripts for each feature are made available. An initial pull request for this proposal can be found at https://github.com/ilastik/ilastik/pull/2995

pythonmercurialjavascript+3
Student: Peter Laszcz
Code

Enhancing Salsa CI: Stats Dashboard, Local Execution, and Faster Pipelines

intermediate
Debian•2025Varies175h (Medium)

This project suggests significant upgrades to Salsa CI (Debian's Continuous Integration system) used by more than 27,000 source packages by adding an effective statistics dashboard, resolving issues, making the pipelines faster, and doing smart job skipping for non-functional changes. Altogether, these enhancements are hoped to streamline the CI process, save resources, and empower Debian maintainers with improved insight, quicker feedback loops, and a smoother development experience.

pythonjavascriptc/c+++8
Student: Aayush (@44yu5h)
Code
Proposal

System for Checking Game Files Integrity

intermediate
ScummVM•2025Varies175h (Medium)

This project aims to finalize the system for verifying the integrity of game files within ScummVM. It introduces a server-client architecture where hash-based checksums are computed for game files and compared against a curated database. The system provides moderators tools to validate, merge, and maintain the database. A major focus is on automating the pipeline, enhancing moderation tools, and addressing edge cases.

openglc++assembly+5
Student: Shivang Nagta
Code
Proposal

Asynchronous I/O Framework

advanced
The NetBSD Foundation•2025Varies350h (Large)

The aim is to refine the capabilities of asynchronous I/O within NetBSD. A program that utilizes asynchronous I/O is able to invoke multiple file operations and continue executing without blocking on their explicit completion. The guiding principle is to keep submission cheap, coalesce work sensibly, and only spawn worker threads when the kernel would otherwise block. Today much of the path within the kernel still behaves synchronously; even so there are performance gains when working with different files, and the work lays the groundwork for future optimizations in concurrency on the same file. We are investigating practical paths forward by drawing on designs that decouple submission from waiting so the system may stall less, with a clear route towards maximal parallelism as lower layers mature (e.g. the buffer cache).

networkingkernelbsd+13
Student: Ethan Miller
Code
Proposal
Showing 1609 - 1632 of 13453 Projects
6667686970
Proposal
Proposal
Proposal
Proposal