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

Implement a Wishlist Model - Fourier Neural Operator

advanced
DeepChem•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 aims to implement the Fourier Neural Operator (FNO) in DeepChem, expanding its support for solving complex partial differential equations (PDEs) in scientific machine learning. Traditional neural networks often struggle with PDEs due to their reliance on fixed-grid discretization. FNO addresses this by operating in the frequency domain, learning resolution-invariant mappings between function spaces using the Fourier transform, making it both scalable and efficient. The project involves developing a new SpectralConv layer and a high-level FourierNeuralOperator class compatible with DeepChem’s PyTorch backend. The implementation will be modular, enabling future extensions such as Physics-Informed Neural Operators (PINO). Deliverables include the FNO model, unit tests, and a comprehensive tutorial.

pythonnumpypytorch+1
Student: Shrisharanyan Vasu
Code
Proposal

Optimizing Mesh and Multires Sculpting Performance in Blender

advanced
Blender Foundation•2025Varies350h (Large)

The goal of this project is to improve the performance of Blender’s sculpting system, particularly when working with high-resolution meshes. Sculpting can become unresponsive on dense geometry, especially on lower-end hardware, so this effort focuses on optimizing performance at a low level. Key areas of development include spatially sorting mesh vertex data to enhance cache coherence, implementing smarter undo data storage through compression techniques, and introducing multithreading within nodes to make better use of CPU resources. The intended outcome is a noticeably more responsive sculpting experience for artists, with faster interaction and improved overall performance.

cpythonopengl+3
Student: Namit Bhutani
Code
Proposal

PyBaMM - Adding a Dispatching Mechanism for Third Party Models.

intermediate
NumFOCUS•2025Varies175h (Medium)

This project will make the addition and sharing of third-party battery models easier in PyBaMM. It is an extension of the PyBaMM cookiecutter project of year 2024 and will include a Dispatch API, a single location to register models, and enhance model loading using entry points. The copier template will also be enhanced so that individuals with varying levels of experience will be able to use it more easily. By incorporating features such as dynamic model loading, caching, and enhanced documentation, the project will make it easier for more users and developers to work with external models and make PyBaMM more flexible and convenient to use in the long term.

pythonjavascriptr+3
Student: Medha-Bhardwaj
Code
Proposal

Adding embarrassingly parallel graph algorithms in nx-parallel

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

Expanded and enhanced nx-parallel, a parallel backend for NetworkX that leverages joblib to parallelize graph algorithms. I implemented several embarrassingly parallel algorithms, analyzed their performance speedups, and optimized existing implementations with the help of a mem-mapping approach. Additionally, I switched the default configuration to use NetworkX’s system in place of joblib’s, developed a more reliable timing script to reduce measurement variability, introduced a `should_run` mechanism to determine when the parallel backend should be applied, and improved ASV benchmarks by adding setup functions for consistent performance testing. The entire development workflow was documented in a series of eight GSoC blogs, published biweekly throughout the project duration.

pythonjavascriptr+3
Student: Akshita Sure
Code
Proposal

Fine-tuning Vision-Language Models for Object Detection and Hierarchical Classification

advanced
OpenVINO Toolkit•2025Varies350h (Large)

This project aims to fine-tune Vision-Language Models (VLMs) for domain-specific tasks like object detection and hierarchical classification, focusing on real-world applications in fields such as medical diagnostics and biodiversity monitoring. Although VLMs like BLIP-2 and TinyCLIP show strong general-purpose performance, their effectiveness diminishes in specialized domains due to domain shifts, hierarchical label structures, and hardware constraints. To address this, we will implement efficient fine-tuning strategies—including LoRA, QLoRA, and adapter tuning—within the OpenVINO Training Extensions (OTX), enabling scalable training on consumer-grade GPUs. We’ll enhance these models with support for structured prediction and deploy them using OpenVINO’s quantization and optimization toolchain, ensuring fast, lightweight inference across devices. Beyond technical contributions, the project delivers practical tools and open-source pipelines that bring advanced multimodal AI to resource-limited environments. By supporting transparent, efficient deployment of VLMs in impactful domains, this work bridges cutting-edge research with high-value, real-world use cases.

pythonc++x86+1
Student: Jiayu Li
Code

RoboStream: Real-Time Telemetry & Vision Platform.

advanced
Liquid Galaxy project•2025Varies350h (Large)

RoboStream is a comprehensive solution designed to address the challenge of monitoring and visualizing complex robotic telemetry in real time. As robots become increasingly integral to various industries, the need for an intuitive, immersive interface to track sensor data and live video streams grows ever more critical. Our project integrates advanced simulation tools and real robots with a responsive, cross-platform mobile application built in Flutter. This combination lets us capture, process, and transmit detailed telemetry directly into the immersive Liquid Galaxy multi-screen environment.

javascriptrosgis+14
Student: alexbernaldo
Code
Proposal

DashBot and API Authentication

advanced
API Dash•2025Varies350h (Large)

I will be developing DashBot - the AI assistant for API Dash which supercharges developer productivity by helping developers automate tedious tasks, follow best practices, interact & obtain contextual suggestions, all via natural-language input. DashBot will be designed in a modular and extensible manner and provide the following list of features: 1. Explain responses & identify any discrepancy 2. Debug requests based on Status codes & Error messages 3. Generate API documentation 4. Understand API and generate tests 5. Generate plots & visualizations for API responses along with ability to customize 6. Generate API integration frontend code for frontend frameworks like React, Flutter, etc. For each of the tasks benchmark evaluations will also be done so that it is easier for end users to choose the right backend LLM. Add support for various API Authentication Methods such as, Basic authentication, API Auth, API key, Bearer token, JWT Bearer, Digest Auth, OAuth 1.0, OAuth 2.0.

flutterapiai+5
Student: Udhay Adithya J
Code
Proposal

Communication Analysis Tool for Human-AI Interaction Driving Simulator Experiments

beginner
HumanAI•2025Varies90h (Small)

I propose to make an AI-powered tool that can analyze complex communication data from driving simulator experiments at the Translational Research for Injury Prevention (TRIP) Laboratory. The tool will process high-fidelity audiovisual data from six participants working together in networked simulators. Building on my previous work in audio extraction, transcription, sentiment analysis, and preliminary visualization, I want to create a complete solution that includes strong data pipelines, advanced NLP techniques (such as speaker diarization, NER, and topic modeling), dynamic reporting with interactive visualizations (heat maps, network graphs), and an easy-to-use user interface. The final product will be a fully functional prototype with full documentation that will help researchers learn more about how groups work together, how people talk to each other, and how drivers act in order to improve safety and inform the design of smart systems.

pythonmachine learningc+++2
Student: eskayML
Code

AI-Powered Agent to provide support for Zendalona products

intermediate
Zendalona•2025Varies175h (Medium)

I will build an accessible AI support agent for Zendalona product.. This project addresses a critical gap in accessibility support by creating a conversational interface that seamlessly accepts both voice and text input, allowing users to interact naturally with Zendalona's product ecosystem. The technical architecture employs an Agentic Retrieval-Augmented Generation (RAG) approach using LlamaIndex. This system will methodically index all Zendalona product information, documentation, and support materials in a vector database (ChromaDB or FAISS). When users submit queries, the system retrieves contextually relevant information and passes it to a large language model alongside the query, enabling precise, helpful responses based on accurate product knowledge. The implementation follows a three-tier approach: First, a comprehensive data ingestion pipeline that processes, cleans, and vectorizes Zendalona's product information. Second, a robust Python backend built with FastAPI that handles query processing, context retrieval, and response generation through integration with STT/TTS services and LLM APIs. Third, a fully accessible React-based multimodal chat interface featuring high-contrast text, complete keyboard navigation, ARIA attributes, and seamless screen reader compatibility, particularly with Orca. Key deliverables include a modular, containerized system with separate frontend and backend Docker containers orchestrated via Docker Compose, comprehensive API documentation, extensive accessibility testing results, and detailed user guides. The solution prioritizes WCAG 2.2 compliance, minimal latency, data privacy, and security throughout the architecture. The final product will provide visually impaired users with an intuitive, conversational way to access product support that works effectively with their existing assistive technologies.

pythonjavascriptandroid+2
Student: Ashish Baghel
Code
Proposal

Neural Harmony – Decoding Social Interactions with CEBRA-based framework for analysing EEG data

intermediate
Machine Learning for Science (ML4SCI)•2025Varies175h (Medium)

This project aims to decode the neural dynamics of social interactions by adapting the CEBRA framework to analyze dyadic EEG data. Focusing on differences between neurotypical individuals and those with autism, the work will develop robust preprocessing pipelines, contrastive learning methods for neural synchrony, and interpretable clinical biomarkers. The deliverables include an open-source toolkit for EEG analysis, enabling researchers to study brain interactions with greater precision. This approach could advance early diagnosis and deepen our understanding of social brain function.

pythonmachine learningc+++2
Student: Maria Glushanina
Code
Proposal

Gemma Chat Gradio Demo

intermediate
Google DeepMind•2025Varies175h (Medium)

A majority of the Gemma chat applications on Hugging Face Spaces do not allow the user to adjust generation settings or system prompts, giving the user only a generic experience. This project aims to provide users with total control of the model. Users will be able to fine-tune settings such as temperature, top-p, repetition penalty, and max tokens, allowing for a more personalized experience. Additionally, the project will introduce a range of predefined model personalities as well as custom context, enabling users to choose from different response styles, tones, and behaviours that best suit their preferences and use cases. I will deliver an open-source web application with comprehensive documentation accompanying it, which includes instructions, usage guides, and explanations of how different parameters influence the model's output. I believe that this project will be a valuable addition to the Gemma ecosystem on Hugging Face.

pythonjavascripttypescript+2
Student: AndyC
Code
Proposal

Flashbacks

intermediate
Oppia Foundation•2025Varies175h (Medium)

The current app experience can be frustrating for learners who are redirected to earlier concepts for revision after making a mistake, as they must re-answer all intermediate questions to return to their original point. This proposal introduces a new Flashback feature that allows learners to view the correct answer or revisit previously solved question answer tied to their misconception and then return directly to the point where they became stuck—eliminating the need to reattempt intermediate steps. This reinforces foundational understanding while enabling a smoother, frustration-free learning journey. Additionally, this project improves the visual presentation of submitted answers for multiple choice and item selection interactions by replacing the current HTML-based approach with a cleaner, natively rendered experience.

pythonjavascriptangularjs+10
Student: Subhajit Mallick
Code
Proposal

Reimplementing the Core Samplers of the dirichletprocess R Package in C++

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

This project aims to address performance limitations of the dirichletprocess R package by reimplementing its computationally intensive core sampling algorithms in C++ while maintaining the existing R interface. The current pure R implementation faces significant scaling challenges with larger datasets. By leveraging Rcpp and RcppArmadillo for seamless integration, I will optimize the MCMC sampling algorithms—particularly the Chinese Restaurant Process sampler and cluster update functions—which are inherently sequential and difficult to vectorize in R. This reimplementation will significantly enhance package performance while preserving the flexible, object-oriented design that distinguishes dirichletprocess from other implementations and allows it to serve as building blocks in custom hierarchical Bayesian nonparametric models.

cc++r+4
Student: priyanshuTiwari
Code

Implementing MicroPython Support and Packaging It For RTEMS

intermediate
RTEMS Project•2025Varies175h (Medium)

This project aims to implement a MicroPython REPL, script running functionality and access to RTEMS (and perhaps LibBSD) APIs, and package it by creating an RSB recipe. The effort would also include tests, creating setup and usage examples, writing documentation for both using MicroPython with RTEMS and the implementation of support for future RTEMS APIs in MicroPython. An optional goal of this project would be to create a BSP for a popular and accessible board like the Raspberry Pi Pico to position it, along with MicroPython support, as an entry point into RTEMS for new users.

cpythonembedded systems+5
Student: l1zard
Code
Proposal

Quantum Machine Learning For Exoplanet Characterization

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

This project investigates the potential of quantum machine learning methods, such as quantum feature encoding and quantum neural networks (QNNs), for the characterization of exoplanet atmospheres using transmission spectra. The goal is to assess how well quantum representations preserve and separate atmospheric features compared to classical approaches, and to determine whether QML-based models can provide meaningful advantages in estimating atmospheric properties and identifying molecular signatures. Performance is benchmarked against established classical models to evaluate both the scientific utility and the practical feasibility of QML in this domain.

pythonmachine learningc+++2
Student: Sourish Phate
Code
Proposal

Public Courses on github

intermediate
omegaUp•2025Varies175h (Medium)

The proposal outlines a project to migrate the management of omegaUp's public courses to GitHub, enabling open-source contributions and improving collaboration, version control, and deployment consistency. Currently, omegaUp's public courses are managed manually, which can be time-consuming and lacks community involvement. By using GitHub, contributors can submit pull requests (PRs) to update course content, which will be automatically validated and deployed using GitHub Actions and omegaUp's API. Key components of the project include: 1. Course Migration: All public courses will be uploaded to a GitHub repository, structured by course and content type (lectures, problems, etc.). 2. CI/CD Workflow: A GitHub Actions pipeline will validate and deploy updates when a PR is merged. This pipeline will automatically check for any changes in problems and deploy only the modified content. 3. API Integration: The system will use omegaUp’s API to upload content after successful review and approval of changes. 4. Community Collaboration: Contributors can suggest improvements via PRs, with a review process ensuring quality control before deployment. 5. Automated Testing: The CI/CD pipeline will run validation scripts to check metadata, problem structure, and other course details before deployment. 6. Security: A review and approval mechanism will prevent unauthorized or malicious content from being deployed. The project aims to enhance omegaUp’s educational content by leveraging GitHub’s collaboration model, ensuring faster updates, better quality control, and reduced manual workload for omegaUp staff. A proof of concept has been set up in a sample GitHub repository, where contributors can simulate the entire workflow by submitting PRs and seeing automatic deployments on omegaUp. This approach is expected to streamline course management, making it scalable and more responsive to community-driven improvements.

pythonmysqlphp+2
Student: Anas Iqbal
Code
Proposal

AI bot for community support

advanced
The Mifos Initiative•2025Varies350h (Large)

The Mifos community has grown significantly over the years, along with the increasing number of projects and discussions happening across its platforms. Newcomers, as well as contributors unfamiliar with specific parts of the ecosystem, often struggle to navigate and understand the breadth of information shared. While the general Slack channels host a wealth of discussions, support is inconsistent and depends on the availability and responsiveness of community members. Similarly, valuable insights are often scattered across community blogs, mailing lists, and Jira tickets, making it challenging to locate relevant information quickly. To address these challenges, this project proposes the development of an AI-powered chatbot that leverages messages from Slack channels, posts from community blogs, updates from Jira, and other conversational and announcement platforms used by the Mifos Initiative. The chatbot will be capable of answering queries related to project updates, community decisions, usage guidance, and more—based on real-time information and past conversations. The core system will utilize a Retrieval-Augmented Generation (RAG) pipeline to dynamically pull relevant data from these sources and serve accurate responses to user questions. The system will also evaluate different vector stores and embedding strategies to optimize retrieval from unstructured conversational data. By the end of the project, the Mifos Initiative will have an intelligent AI assistant that significantly improves community support, provides instant clarity on ongoing discussions, and makes the ecosystem more approachable for contributors at all levels.

mysqljavascriptandroid+5
Student: Aru Sharma
Code
Proposal

Containerized Deployment of Airavata Services

beginner
Apache Software Foundation•2025$1.5k–$3.3k90h (Small)

My project for GSoC 2025 focuses on improving the deployment process of Apache Airavata by containerizing its core services using Docker. Currently, Airavata services are packaged as Java bundles, which makes deployment complex, inconsistent across environments, and difficult to manage. My goal is to create Dockerfiles for each service and set up a complete Docker Compose environment for easy local development and testing. I will also integrate CI/CD pipelines using GitHub Actions or Jenkins to automate the build and deployment processes. This will not only simplify dependency management and make deployments more reliable but also improve the overall development experience for contributors. Throughout the project, I’ll optimize the Docker images for production use, support different configurations for development and production, and provide full documentation along with a final demo. With my background in DevOps, containerization, and open-source contributions including work on MetaCall, OpenMRS, Apache Hadoop, and Airavata itself I’m confident in my ability to deliver a high-quality solution that will benefit the Apache community.

pythonjavascriptjava+7
Student: Yasindu Dissanayake
Code
Proposal

Implementing minigame interface in qdEngine

advanced
ScummVM•2025Varies350h (Large)

Last year, qdEngine was ported to ScummVM. However, not all games are supported yet. Games with advanced minigames are not playable, and some titles need playtesting. This project will address these problems. My first main goal is to implement the advanced minigame interface, which will help advanced minigames be playable. Secondly, I will be going through the rest of the games, identifying issues and fixing bugs along the way.

openglc++assembly+5
Student: Alikhan Balpykov
Code
Proposal

Enhancing Debian packages with ROCm GPU acceleration

intermediate
Debian•2025Varies175h (Medium)

Due to Debian’s open-source nature, no Debian package in main can have a proprietary GPU package listed as a dependency. While AI and HPC workloads increasingly rely on GPU acceleration, many Debian packages still focus solely on CUDA, which is proprietary. With the advent of ROCm, an open-source GPU computing platform, we can now integrate full-fledged AMD GPU support into Debian packages. This will improve the experience of developers working in AI/ML and HPC while positioning Debian as a strong OS choice for GPU-driven workloads. The proposal aims to aid in solving the aforementioned problem by packaging several ROCm packages for debian and add ROCm support to some existing debian packages. The deliverables are - New Debian packages with GPU support, Enhanced GPU support within existing Debian packages and More autopackagetests running on the Debian ROCm CI.

pythonjavascriptc/c+++8
Student: Spaarsh
Code
Proposal

Add Virtual DAI component to SOF

beginner
The Linux Foundation•2025Varies90h (Small)

The project aims to implement a Virtual Digital Audio Interface (DAI) for the Sound Open Firmware (SOF) to facilitate debugging, rapid prototyping. The Virtual DAI will support two directions: playback, which consumes data similarly to /dev/null, and capture, which generates data like /dev/zero or /dev/urandom. Expected outcomes include successfully merging the Virtual DAI component upstream, enabling simple playback and record pipelines, logging and discarding output frames for playback, and generating zero-filled frames for recording.

cpythonmysql+7
Student: Suraj Sonawane
Code
Proposal

Scaladex: Support for Compiler Plugins

intermediate
Scala Center•2025Varies175h (Medium)

Scaladex, the central index for open-source Scala libraries, currently does not have dedicated support for Scala compiler plugins—special artifacts used to extend or modify compiler behavior. These plugins are vital tools in the Scala ecosystem but are difficult to discover due to lack of indexing and classification. This project proposes adding full support for Scala compiler plugins in Scaladex. The implementation includes extending the binary version parser to recognize plugin naming conventions, adding a new platform type (CompilerPlugin), and integrating plugin-specific metadata into the indexing pipeline. The user interface will be updated to allow filtering and discovery of compiler plugins, and best practices for plugin authors will be documented. The key deliverables of this project include: Parsing and indexing improvements to recognize compiler plugin artifacts. UI enhancements for discoverability, including tags and platform filters. Updated documentation and contribution guidelines for plugin maintainers. A technical blog post summarizing design decisions, edge cases handled, and outcomes. By implementing these features, this project will significantly improve the visibility, discoverability, and usability of compiler plugins in the Scala community.

#scala#scala_lang#jvm+7
Student: Vidisha Gawas
Code
Proposal

Django Templates: Bring django-template-partials into core

intermediate
Django Software Foundation•2025Varies175h (Medium)

Django’s template language does not currently provide a built-in way to define and reuse small fragments within the same file, a feature that is valuable for component-based design and partial page updates (such as with HTMX). This project introduces that functionality into Django by adding new template tags to define and render partials, as well as support for loading and rendering specific fragments using a template#fragment syntax. The template loading system was extended to make fragment rendering work seamlessly across includes and other loading functions. The work also delivered a comprehensive test suite, full documentation of the new features, and a migration guide for existing users of the third-party package.

pythondjango
Student: Farhan Ali Raza
Code
Proposal

Improve I/O performance in the libc implementation for GPU using io_uring

advanced
LLVM Compiler Infrastructure•2025Varies350h (Large)

Many HPC applications rely on GPUs for fast and efficient computation. At the same time, there is an effort to bring more programmability and portability when writing code for the GPU. One of such efforts is the implementation of the libc and libc++ in LLVM project for execution on the accelerator itself. This allows standard host applications to run on the GPU automatically, without modification to the user code. One consideration of such an approach is that some functions are not natively supported on the GPU and rely on RPC calls to the host. This poses a limitation on the bandwidth of data transfer. Thus, this project aims to improve current file operations triggered by GPU, leveraging the new Linux io_uring interface. io_uring allows the program to register a queue to asynchronously request file operations and pool the completion by interacting with such a queue. Apart from registering the queue, requesting and polling operations do not require a syscall, making it faster and more flexible than regular POSIX operations or Linux AIO calls. We will map and register/pin a memory region on the GPU side and use that region for io_uring interaction, driven by the GPU. We expect such a process to deliver more performance than current RPC round-trips to complete I/O transfers, which require a CPU polling thread for each request and do not come close to the theoretical bandwidth of PCIe interfaces.

cllvmc+++3
Student: Rodrigo Ceccato
Code
Showing 2089 - 2112 of 13453 Projects
8687888990
Proposal
Proposal
Proposal
Proposal