Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
The project aims to develop an intelligent code review agent that integrates with GitHub and other version control systems (VCS). This tool will provide automated, insightful feedback on code quality by combining traditional static analysis with AI-powered insights. Problem Being Solved Code reviews are often time-consuming and inconsistent, especially when identifying complex issues such as security vulnerabilities, performance bottlenecks, and maintainability concerns. This project addresses these challenges by automating the review process while providing actionable, contextual feedback. Proposed Solution The solution employs a modular webhook-based architecture with the following components: 1. A webhook receiver to capture GitHub events (e.g., pull request creations/updates). 2. A code fetcher to retrieve and parse changed files. 3. An orchestrator to coordinate multiple analysis tools. 4. A result aggregator to combine findings and remove duplicates. 5. A response handler to post intelligent comments directly on pull requests. Key Deliverables 1. A system that provides actionable, contextual feedback rather than merely flagging issues. 2. Support for multiple programming languages (initially Go, JavaScript, and Python). 3. Implementation of dependency vulnerability detection. 4. An AI-powered layer to enhance basic linter outputs. 5. Extensibility for future language support and additional features.
This project will investigate algorithms for forecasting based on traditional machine learning (tree based) and time series machine learning (transformation based). It will involve helping develop the aeon framework to process both standard ML and extrisnic regression algorithms for forecasting. This will involve evaluating regression algorithms already in `aeon` for forecasting problems as well as `scikit-learn` regressors. The tree-based SETAR-Tree and SETAR-Forest algorithms will also be implemented in the forecasting module.
This project aims to develop a feature that enables users to import their listening history from various services, including ListenBrainz exports, Spotify, etc. The proposed solution involves creating a backend API endpoint to handle file uploads, building normalizers to parse and validate data from different services, and converting the data to the JSONL format required by ListenBrainz. The solution also includes a frontend to handle file uploads and show the progress to the user. This project will help contribute to the completeness and accuracy of ListenBrainz data.
Currently, certain essential signal-processing functions, called kernels here, in volk-gnssdr, the Vector-Optimized Library of Kernels for GNSS-SDR, are not completely optimized. This project hopes to diagnose performance-limiting kernels, implement missing SIMD/vector optimizations for both ARM (NEON) and RISC-V architectures (vector, or V, extension), then benchmark and validate the kernels’ continued functionalities.
The DBmaps package aims to simplify and automate the analysis of complex relational data in R. A common challenge in data analysis is the need to first aggregate event-level "fact" tables (e.g., transactions, views) before they can be meaningfully joined with descriptive "dimension" tables (e.g., customers, products). This process is often manual, repetitive, and error-prone. DBmaps solves this problem by providing a metadata-driven framework for metaprogramming. Instead of writing complex data.table code by hand, users define the analytical potential of their database in a simple, machine-readable format. The package then uses this "map" to automatically generate and execute the necessary aggregation and join code, making the entire workflow more efficient, consistent, and scalable.
The OpenMRS Standalone version is outdated, no longer builds successfully with the latest releases, and has been deprecated. However, many users—especially those in resource-limited settings—still rely on it because it offers a simple, self-contained installation without requiring advanced IT skills. This project aims to replace the OpenMRS Standalone with a modern, lightweight, and easy-to-use alternative that works on Windows, macOS (including Apple Silicon), and Linux. The new setup will use a Java-based local installation that allows users to double-click and run OpenMRS, mariadb4j for an embedded- hassle-free database solution, docker Compose (only for CI/CD) to automate testing and deployment pipelines. By the end of the project, OpenMRS will have a user-friendly, cross-platform installer, an embedded database, and an automated build process for multiple OpenMRS versions (2.x, 3.x, and Core Platform 2.7.x+).
The integration of the Robot Operating System (ROS) Framework as an option within Automotive Grade Linux (AGL) through the meta-ros yocto layer is an important step in upgrading vehicle technology using automotive systems. This project is important for several reasons: * Bridging the Gap Between Robotics and Automotive Software * Expanding AGL’s Capabilities * Advancing Open-Source Development * Enhancing Real-World Use Cases
The Verilog feature in CircuitVerse has been a great experimental addition till now. It has allowed users to write, experiment, and test their Verilog code along with graphical circuit design using CV simulator. But currently, the Verilog feature is full of bugs, unstable, and unreliable which leads to its failure and causes loss of trust in CircuitVerse among its userbase. The project aims to fix the bugs, make the Verilog feature stable, refine the Verilog interface, make it more intuitive, enable users to generate, view, edit, test circuits comprehensively, and fix the testbench generation feature for Verilog code. Other goals include adding detailed documentation for Verilog and added improvements to assist users. Additional enhancements like adding play/pause functionality to simulator, and implementing full-screen view for the Boolean Logic Table is also covered in this project.
The Mifos and Apache Fineract platforms, while offering comprehensive core banking solutions, present challenges in documentation due to their technical complexity and extensive domain-specific knowledge. To address this, the proposed project aims to leverage a class of large language models (LLMs) based on transformer architectures(especially reasoning based), to enhance documentation accessibility and user support. Building upon a preliminary LLM developed in 2024, the 2025 initiative will focus on scaling this system across the full documentation set, which involves scraping all the necessary sites,sublinks,slack channels and even youtube videos via their transcripts. This new project aims to completely revamp the way a normal Q&A chatbot does by leveraging state of the art models and latest techniques.
This project aims to develop a user-friendly, browser-based interface for oceanographic data quality control tools. The goal is to create an interactive interface for oceanographers to validate and analyze their datasets. The project will also include data visualizations to display the results of quality checks and compliance tests. Additionally, the users should be able to download the processed datasets. Deliverables: • A browser-based interface for uploading datasets and selecting quality checks. • Integration of ioos-qc and compliance-checker with the browser. • Visualizations of quality control results. • Functionality for users to download processed data. • Documentation and a final report detailing the development process and outcomes. The project will provide a convenient, accessible platform for oceanographers to validate and analyze their data, improving the efficiency and accuracy of their quality control workflows.
This project aims to improve probabilistic solar forecasting by replacing traditional quantile regression with a more expressive Gaussian Mixture Model (GMM) approach. Instead of predicting fixed quantiles, the model will learn the parameters of a GMM to represent the full predictive distribution, capturing complex and multimodal uncertainties common in solar irradiance data. Deliverables include a GMM-based forecasting model, performance comparisons with quantile baselines, robust uncertainty evaluation, and well-documented code for reproducibility and future extension.
This project aims to extend the existing capabilities of ReachabilityAnalysis.jl with a new state-of-the-art algorithm for reachability analysis, based on recent literature. The algorithm will improve the precision of reachable set computations for systems with uncertain parameters, utilizing matrix zonotopes—a set representation that provides tighter enclosures than traditional convex sets. Building on recent research, I will develop a new Julia package, MatrixZonotopes.jl, which will provide the necessary operations for working with matrix zonotopes and integrate it into the JuliaReach ecosystem. Based on the functionalities added by the new package, a reachability algorithm for linear systems will be implemented. At the end of the project, the new package will be available, along with the reachability algorithm, and a blog post will document their performance and functionalities.
GitHub issue: Opencv #27206, Opencv_contrib #3921 Fork with WIP: https://github.com/MykhailoTrushch/opencv_contrib As part of GSOC 2025 idea 11, implement algorithms for enhancement of technical quality of images. Based on the conversation in opencv-gsoc-202X mailing list, the main prioritized algorithms are: Smarter white balance algorithms Color corrections vignetting correction, chromatic aberration correction Exposure, contrast, temperature correction and enhancement in color images In my proposal, I outline some possible algorithms that would in the beginning be implemented for opencv_contrib and could be migrated to opencv, mostly in the photo module. In particular, in order of approximate importance: Auto white balance: implement FFCC Chromatic aberration correction: implement algorithm of Chang et al. Denoising: implement a CNN-based method as a module like dnn_superres Exposure correction: implement (Adaptive, Weighted) Gamma Correction Superresolution: check if any additional newer models for superresolution could be added If I am accepted as a contributor in GSOC, I expect to pursue 2-3 of these topics in-depth to fit in the timeframe of the medium-sized project (~175 hours). Also, the choice of algorithms is preliminary and might change after additional research and feedback.
This project aims to integrate Swiftly with the Swift Extension for VSCode. It should allow users to install Swiftly and Swift toolchains in the VSCode editor toolchains directly within the VSCode editor. Currently, we have the “Swift Extension of VS Code,” which provides code completion and LSP integration, error annotations with applicable suggestions, automatic generation of launch configurations for debugging, automatic task creation, Swift PM integration, and test explorer view. Since different projects may require different versions of Swift toolchains, we want to integrate with Swiftly to provide a seamless toolchain selection experience in VSCode.
This project focused on enhancing the reliability of the Federated Credential Management (FedCM) API's automated test suite. The primary objective was to address and systematically reduce test flakiness within the Web Platform Tests (WPT), with the goal of achieving a stable, green dashboard on wpt.fyi for Chromium. By investigating intermittent failures and refining test expectations, this work significantly improved the stability and trustworthiness of the test suite, ensuring a clear and reliable signal for the API's ongoing development and cross-browser implementation.
Project with MalariaGEN focuses on building a machine-learning tool to classify species of Anopheles mosquitoes (the main carriers of malaria) using their genomic data, which is essentially the complete DNA blueprint of each insect. Since these mosquito species look identical but behave differently in spreading disease and resisting controls, accurate identification is crucial for effective public health strategies in affected regions like sub-Saharan Africa. Starting from an existing random-forest classifier trained on a massive dataset of over 25,000 mosquito genomes from the Malaria Vector Observatory, goal is to optimize it for speed and accuracy, handle large-scale data efficiently in a cloud environment, and package it as an accessible Python library with a simple API and command-line interface, so any researcher or developer can easily integrate it into their workflows without needing deep expertise in genomics or machine learning.
There are many secondary goals for this project, but the main goal is to make the fuselage compatible with React Native. But also, we have figthing against the bundle size of the fuselage, and of course performance which is always a concern. Using the tamagui as a base, we can components that are compatible with both platforms, and in a efficient way.
The new 3.0 release of GIMP introduced many API changes that require all third-party plugins to be updated. Notably, a new filter API for using GEGL filters replaced an old compatibility API. This provides a new level of flexibility and convenience at the expense of discoverability. Plug-in and filter creators need an accessible and convenient way of discovering what GEGL filters they can make use of. Overall, the plug-in/filter development experience could be improved. Especially the discoverability of available APIs and where to find them. In this project I want to implement a new browser for discovering which GEGL filters are available and how they can be used from a plug-in/filter. Then, I want to explore how to merge existing procedure and plug-in browsers with the newly implemented one. Lastly, I want to explore how to further enhance the development experience. Some options are (a) making additional API documentation available in the GIMP UI, (b) doing research with plug-in/filter developers to learn about their problems and experiences.
This project aims to enhance the monitoring capabilities of OneBusAway (OBA), an open-source platform that provides real-time transit information to riders across multiple cities. The focus is on improving Watchdog, a Go-based backend service that tracks the health and data integrity of OBA servers by reporting detailed metrics to Prometheus. In the past, a Python script was used to monitor the system by checking real-time API data and identifying issues such as expired transit bundles or data mismatches. However, this legacy solution lacked flexibility and scalability. The current Watchdog framework, built in Go, addresses these shortcomings but still requires the addition of several key metrics. The proposed solution builds on the existing Go codebase, expanding and refining the metrics to ensure accurate, real-time tracking of issues such as unmatched trips, stale data, and anomalies in transit information. The project also prioritizes maintainability by refactoring code, implementing robust error reporting through Sentry, and ensuring comprehensive test coverage to maintain reliability. Key deliverables include: Implementation of multiple high-priority metrics Complete test coverage and improved modularity of the codebase Clear, user-friendly documentation A production-ready, extensible monitoring service for OBA This work will provide transit agencies with better insights into data health and system performance, ultimately enhancing the experience for thousands of daily riders.
Fine-tuning LLMs like Gemma requires deep ML expertise and complex setups, slowing down adoption of SLMs in various industries and communities despite their rapid advancements. Existing resources like Colab notebooks aren’t scalable for real-world workflows. Facet AI solves this with a no-code web platform that streamlines the entire fine-tuning process—from dataset curation to model deployment. It supports multiple post-training methods, including full fine-tuning, PEFT, SFT, and RFT, with built-in evaluation and export tools. Powered by Google Cloud, Facet AI removes technical hurdles so teams can focus on building innovative text and multimodal applications.
The Raspberry Pi OS Bullseye released with a new open camera stack libcamera, while VideoCapture did not integrate with the new camera backend in time. Given libcamera blocked the access from OpenCV to legacy camera backend V4L2, VideoCapture have to implement support for libcamera backend. A proper approach is to wrap libcamera's APIs in VideoCapture.
LLVM currently lacks a type capable of representing raw memory, similar to unsigned char, char and std::byte in C/C++. The absence of such a type is the root cause of many unsound optimizations, such as the lowering of calls to memcpy/memmove/memcmp to integer loads of the corresponding bitwidth. This optimization is incompatible with the use of pointer provenance, as loading a pointer from memory as an integer discards provenance information, leading to miscompilations. This project aims to introduce a new byte type to the IR, capable of representing raw memory, and lower the char, unsigned char and std::byte C/C++ types to the new type. It also addresses the incorrect lowerings of memory related intrinsics, providing a way to natively implement such intrinsics in the IR, fixes optimizations that do not correctly account for type punning, and adds support for the byte type in the Alive2 optimization verifier.
Package Large Language Model (LLM) inference libraries, in particular vLLM. It is needless to explain how LLMs are important. Currently, the Debian archive only has PyTorch, but downstream applications are still missing. One of the most promising downstream applications is LLM inference. There are already people working on llama.cpp and Ollama, but vLLM still lacks lots of dependencies to land onto Debian. For multi-GPU inference and concurrency, vLLM has its advantages over llama.cpp. The missing packages are, for instance, transformers, huggingface-hub, etc. This project involves the Debian packaging work for vLLM and its dependencies that are missing from Debian, as well as fixing issues (if there are any) in existing packages to make vLLM work. Timelplan ~ 5/8: Start with the architecture-independent package and non-cuda variant. 5/8 ~ 6/1: I will start with the architecture-independent package and non-cuda variant. I already created the package for huggingface-hub so I think this is a good start and doesn't take much time. By this time, I will finish the package for tokenizers packaging. 6/1 ~ 6/30: Create the package for the transformers package. Then I will finish rest of the package for the vLLM package. 6/30 ~ 7/18: I will try to build the vLLM package with cuda variant. Now, I already checked that vllm works on CUDA 12.4 so I will try to build the package with CUDA 12.4 with a specific GPU(Maybe T4?). 7/18: Mid-term evaluation 7/19 ~ 7/30: Try to build the vLLM package with multiplatform. I will try to build the package with different CUDA versions and different architectures, including a multi-GPU environment. I will get the feedback from the mentor and continue to the next step. 8/1 ~ 8/25: I will try to finish the project as soon as possible and try to fix the issue. If I have some more time, I will continue with the SGLang packaging. 8/25 - 9/1: submit final work product.
This project creates a comprehensive pipeline for extracting text and complex tables from scientific literature PDFs. By combining PyMuPDF, specialized table detection models, and Vision-Language Models (VLMs), the system will significantly improve accuracy over traditional OCR methods while maintaining cost efficiency. The pipeline allows users to upload multiple research papers, select their preferred extraction method, and receive structured markdown outputs with preserved document hierarchy. A side-by-side interface will enable human verification and correction of extraction results. The solution will be optimized for lightweight deployment on platforms like Hugging Face Spaces, making it accessible to researchers worldwide while focusing primarily on complex table formats common in life science research.