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

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

advanced
R project for statistical computing•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 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
Proposal

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

Implement activity analysis for reverse-mode differentiation of (CUDA) GPU kernels

advanced
CERN-HSF•2025Varies350h (Large)

GPUs and CUDA have revolutionized computing beyond graphics rendering, becoming essential in various fields due to their parallel processing capabilities. Clad, a Clang plugin, provides automatic differentiation for C++ functions by modifying Abstract-Syntax-Tree using LLVM compiler features. While Clad supports reverse-mode differentiation of CUDA kernels, data-race conditions are very frequent and considerably slow down the execution. Thread Safety Analysis helps detect data races to optimize performance by potentially reducing atomic operations in generated code.

pythonc/c++machine learning+6
Student: Maksym Andriichuk
Code
Proposal

Enhancing GCompris Server with GUI Sub-Programs for Dataset Creation

intermediate
KDE Community•2025Varies175h (Medium)

This project aims to enhance the GCompris educational suite by introducing a set of intuitive, GUI-based tools tailored for teachers. These tools will allow educators to easily create and manage custom datasets for various activities, improving adaptability and personalization in the learning experience. The activities targeted for dataset creation include: 1.Grammar Analysis 2.Graduated Lines 3.Decimal Numbers 4. Share 5.Fractions Create The core of the solution involves building user-friendly interfaces using QML, allowing teachers to input data without dealing with raw JSON or technical configurations. On the backend, we will enhance and adapt the activity logic using JavaScript to ensure compatibility with both newly created and existing datasets. These tools will be implemented as modular plugins integrated into the GCompris infrastructure. By empowering teachers to contribute customized content directly, the project fosters a more dynamic and inclusive educational environment, catering to diverse learning needs.

c/c++qtqml+6
Student: Ashutosh Singh26
Code

Enhancing Metals with Play Framework Support

intermediate
Scala Center•2025Varies175h (Medium)

In Metals, the LSP implementation for Scala, there is currently no built-in support for Play Framework-specific files such as .scala.html templates and routes files. This limitation affects essential features like syntax highlighting, linting, and navigation, making it difficult for developers to work efficiently with Play Framework projects in editors that rely on metals. eg. VSCode. This is exacerbated by people who wish to migrate from proprietary editors like IntelliJ which provides such facilities.

#scala#scala_lang#jvm+7
Student: Abdullah Arif Jafri
Code
Proposal

Airavata Research Catalog Local Agent

beginner
Apache Software Foundation•2025Varies90h (Small)

The Airavata Cybershuttle Research Catalog is a web platform that enables researchers to share and run Jupyter Notebooks, GitHub repositories, datasets, and scientific models. It supports project creation by combining resources for collaborative, reproducible research, with direct cloud execution of notebooks and models. To enhance flexibility and performance, a desktop application is being developed: Web Research Catalog - Audience: General users - Pros: No installation required; easy access to shared resources - Cons: Limited by cloud compute resources Local Research Catalog (Desktop App) - Audience: Power users needing high performance - Pros: - Utilizes local machine resources (GPU, RAM) for better performance - Offline access to notebooks, datasets, and models - Integration with local tools and file systems - Seamless synchronization with the web catalog when online - Runs JupyterLab and VSCode sessions locally without needing Docker or external dependencies The local agent is designed to be lightweight, extensible, and user-friendly, with built-in support for running scientific workflows entirely from a desktop environment.

pythonjavascriptjava+7
Student: Ganning Xu
Code
Proposal

NuttX Support for IEEE 802.3-2022 10BASE-T1x Ethernet using Open Aliance SPI MAC-PHYs

intermediate
Apache Software Foundation•2025Varies175h (Medium)

This project aims to add support for IEEE 802.3-2022 10BASE-T1x Ethernet in NuttX using MAC-PHY devices with the Open Alliance SPI interface. These low-cost Ethernet solutions are well-suited for embedded systems, aligning with NuttX’s target use cases. The core deliverables include implementing a reusable driver infrastructure for Open Alliance 10BASE-T1x Serial Interface-compatible MAC-PHYs, with initial focus on the NCV7410 driver, supporting PLCA configuration, porting the driver to the ARM-based platform, and developing a test application. An optional goal is to include support for additional devices (e.g., ADIN1110) following the specification.

pythonjavascriptjava+7
Student: michal matias
Code
Proposal

Adding Wi-Fi Support to QEMU Simulations in LibreMesh

advanced
freifunk•2025Varies350h (Large)

LibreMesh relies on continuous testing to ensure its robustness across various network conditions and hardware setups. Currently, testing new firmware images lacks a standardized method to include Wi-Fi simulations within a virtualized environment. This project aims to add Wi-Fi support to existing QEMU simulations for LibreMesh, allowing near-realistic network testing using virtual Wi-Fi interfaces. By leveraging the mac80211_hwsim module and integrating existing OpenWrt-friendly virtual Wi-Fi tools, we can enhance testing automation and reproducibility. Benefits to the Community - Improved Testing Framework: This project will enable LibreMesh developers to run “almost real” tests in a virtualized environment, improving debugging and validation before deploying changes to physical hardware. - Enhanced Automation: By integrating virtual Wi-Fi support into QEMU, developers can automate complex test scenarios without requiring physical routers. - A set of scripted tests that can be run on real hardware: Currently, real tests on physical hardware are performed manually at each release. With this new set of test scripts for QEMU and Wi-Fi, many tests will be automated and easily adapted to real hardware. - Collaboration with OpenWrt: Given that OpenWrt is also working on virtual Wi-Fi support, this project can align efforts with the broader open-source networking community, benefiting multiple projects. - Lower Barrier to Entry: New contributors will find it easier to test their changes without needing specialized hardware.

cluaopenwrt+15
Student: Victor Spehar
Code
Proposal

Implement Web Extensions & System Settings Integration to Peersky Browser

intermediate
UC OSPO•2025Varies175h (Medium)

The Peersky browser currently lacks a unified system for managing both user-installed WebExtensions and core browser preferences. This project will implement full WebExtension support alongside a customizable peersky://settings page, creating a modular and privacy-focused experience within Peersky’s Electron-based environment. Deliverables include support for installing .zip and Git-based extensions, a persistent extension loader, Manifest V3 validation, CSP-based sandboxing, and a toolbar for pinning and managing extensions. The settings page will also allow users to change themes, set search engines, configure the home page, and manage built-in privacy tools like uBlock Origin and DScan. By the end of the project, Peersky will support a secure, extensible, and decentralized customization system—without relying on centralized extension stores.

pythonc/c++visualization+5
Student: 6cobi
Code

LED BADGE MAGIC

advanced
FOSSASIA•2025Varies350h (Large)

Project Title: Flutter Badge Magic App Mentors: Aditya, MarioB, cweitat Problem: The current Badge Magic app offers limited customization (fixed fonts/colors), lacks interactive features, and restricts users to basic animations and Bluetooth configurations. Additionally, platform-specific deployment and unresolved bugs hinder accessibility and user creativity. Solution: Revamp the Flutter-based app to deliver: Advanced Customization: Support multiple fonts (Google Fonts integration), hex-code color pickers, and 8 editable animation storage slots. Interactive Games: Integrate Snake and Tetris with swipe/tap controls optimized for LED displays. Scalability: Auto-adapt content for diverse LED badge sizes (e.g., 11x44 to 16x45 matrices). Firmware Upgrades: Enable "Bluetooth always-on" mode and power management for stable, energy-efficient connections. Multi-Platform Reach: Automate CI/CD pipelines (GitHub Actions) for Windows, Linux, macOS, and web builds. Deliverables: Feature Enhancements: Font/color picker, editable animation storage (8 slots). Mini-games (Snake, Tetris) with collision detection. Firmware updates for advanced badge configurations. Cross-Platform Support: CI/CD workflows for 5+ platforms/app stores. Testing: 10+ unit/integration tests (90% coverage). Documentation: User guides, API references, and Quick tutorials. Bug Fixes: Resolve existing issues for a polished user experience. Impact: Empower users to create vibrant, interactive LED displays effortlessly while ensuring seamless performance across devices and platforms.

pythonjavascriptandroid+7
Student: Vivek_singh3472
Code
Proposal

From "Stringly Typed" to "Strongly Typed" Arguments in sbi

intermediate
NumFOCUS•2025Varies175h (Medium)

sbi is an open-source Python package used for simulation-based inference. It provides an interface for running algorithms that are used to identify model parameters that are consistent with data. Currently, this project uses “stringly typed” values for its functions' arguments. Even though stringly typed code is flexible and easier to implement, it comes with a set of drawbacks. Using stringly typed code leads to a suboptimal developer experience with limited IDE support and subtle bugs that are hard to identify and fix. This project aims to improve the developer experience and mitigate these issues by updating arguments in functions to use strongly typed code. In addition, it plans to create a pattern for sbi contributors to follow when defining new functions and classes that would otherwise use stringly typed arguments.

pythonjavascriptr+3
Student: Abel Abate
Code
Proposal

VLC for Apple Watch: Standalone Player & iPhone Companion

intermediate
VideoLAN•2025Varies175h (Medium)

This project aims to bring VLC's media capabilities to Apple Watch by developing both a companion app and standalone functionality. The app will enable users to consume audio media directly on their watch by syncing files from their iPhone or streaming content independently. By leveraging the recently added VLCKit support for watchOS and implementing a modern SwiftUI interface, the project will extend VLC's reach to a new platform while maintaining the same commitment to accessibility and quality that VLC is known for.

copenglc+++10
Student: Fahri Novaldi
Code
Proposal

Data Processing Pipeline for the LSST

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

The project, "Data Processing Pipeline for the LSST," is designed to bridge the gap between the LSST data ecosystem and DeepLense's deep learning workflows. The proposal outlines the development of a modular, efficient pipeline that automatically retrieves relevant LSST images and catalogues via the official LSST Butler API, applies configurable preprocessing (such as cutout extraction, normalization, resizing, and channel management), and finally delivers analysis-ready data into DeepLense ML models for tasks like lens detection, classification, and super-resolution. Key deliverables include: 1. A robust LSST Data Access Module that reliably fetches data. 2. A flexible preprocessing module for transforming raw images into ML-compatible formats. 3. Seamless integration with DeepLense’s deep learning workflows, enabling end-to-end processing. 4. Comprehensive documentation and reusable, well-structured code.

pythonmachine learningc+++2
Student: Kartik Mandar
Code
Proposal

Making ZeroMQ A First Class Feature of Concore

advanced
Alaska•2025Varies350h (Large)

Closed-loop peripheral neuromodulation systems, essential for developing adaptive therapies like vagus nerve stimulation that can be modularly simulated using the CONTROL-CORE framework. Although CONTROL-CORE currently supports file-based and shared-memory communication, these approaches have limitations about distributed execution, scalability, and latency. To overcome these obstacles, this project suggests utilizing ZeroMQ that will contribute as a high-performance messaging library as another means of communication.

pythonmysqljava+2
Student: Saksham Gera
Code
Proposal
Showing 1969 - 1992 of 11996 Projects
8182838485
Proposal
Proposal
Proposal