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.
Uyuni is the open-source upstream of SUSE Manager, a configuration and infrastructure management solution for administering multiple Linux systems. To ensure code quality, Uyuni employs two types of tests: 1. Continuous Integration Tests: These tests are run periodically on the master branch to catch breakages that have slipped through earlier testing. When these tests fail, developers must revisit older tasks, leading to frequent context switching and reduced productivity. 2. Pull Request Acceptance Tests: These tests are run on new pull requests to prevent breakages from reaching the master branch. They provide fast feedback to developers, helping them fix issues while they are still focused on their tasks. Currently, Pull Request Acceptance Tests execute most of the test suite, with an average runtime of one hour. This delays feedback for developers and increases infrastructure costs. This project aims to develop a machine learning model that, using past pull requests, test results, code coverage data, and other relevant information, predicts which small subset of tests is most likely to fail for a new pull request. Running only this smaller subset of tests will speed up developer feedback, reduce infrastructure costs, and maintain high test coverage. Inspired by Facebook's Predictive Test Selection paper, this project applies and extends its techniques to optimize Uyuni’s testing strategy and increase developer productivity.
Project Summary: Problem: Renaissance-era Spanish texts remain digitally inaccessible due to modern OCR systems' inability to process archaic glyphs (ligatures, obsolete diacritics), degraded prints, and non-standard orthography. This limits scholars’ ability to analyze historical linguistic evolution and cultural heritage. Solution: Develop an open-source OCR system using a CNN-RNN hybrid architecture tailored for 17th-century Spanish. The model integrates weighted learning to address class imbalance (e.g., rare symbols like ſ or ç) and synthetic data augmentation to simulate historical print degradation. Key innovations include: Weighted loss functions (focal loss, class-aware cross-entropy) to prioritize underrepresented characters. Rule-based post-processing (e.g., positional substitution of ſ → s). Synthetic training data with historical fonts and degradation simulations, alongside real data Deliverables: A trained OCR model achieving ≥80% character accuracy (CER ≤20%). Evaluation metrics (CER/WER) and symbol-specific performance analysis. Codebase with inference scripts, documentation, and sample transcriptions. Impact: This tool will empower digital humanists, archivists, and linguists to transcribe and analyze historical texts at scale, preserving cultural heritage and enabling new research into early modern Spanish. By open-sourcing the system, we aim to democratize access to underserved historical materials and inspire community-driven improvements.
The KServe Models Web App is a crucial front-end interface for managing ML models deployed through KServe, a core component of Kubeflow. However, the application has become outdated, with deprecated dependencies and technical debt. This project aims to modernize and enhance the app by upgrading its tech stack, resolving open issues, and implementing a robust CI/CD pipeline with GitHub Actions. Key improvements include regression testing with Cypress, model editing capabilities, and synchronization with KServe 0.14+. Additionally, the project explores migrating the app from kserve/kserve-models-web to kubeflow/kserve-model-ui for better integration. The deliverables include a stabilized, modernized codebase, improved user experience for ML engineers, and streamlined contributor documentation. This effort will reduce operational overhead, enhance usability, and support Kubeflow’s mission of making ML workflows simpler and more scalable.
The goal of this project is to improve the Chrome Extensions platform by updating existing APIs, introducing new ones, and enhancing the chrome://extensions page and service worker. I will work with Chromium’s code (C++) and extensions (JavaScript) while learning from experts. The deliverables will include: fully implemented features with comprehensive tests, potential W3C WebExtensions Community Group standardization.
This project aims to make the Ubuntu Desktop Provision installer fully accessible to visually impaired users by addressing key accessibility issues in its Flutter-based interface. Currently, the installer lacks proper screen reader support, suffers from poor keyboard navigation, and fails to provide audio feedback, making it unusable for blind and low-vision users, especially those relying on Accessible-Coconut, a Ubuntu-based distribution developed by Zendalona. The solution involves fixing both architectural and UI-level problems in how Flutter components interact with Linux accessibility frameworks (AT-SPI). It will include: - Implementing semantic accessibility wrappers - Ensuring proper focus and navigation flow - Enhancing screen reader feedback using Orca - Improving the accessibility of complex UI components, such as partitioning - Conducting extensive user testing and providing detailed documentation Deliverables - A fully accessible Ubuntu installer with complete screen reader compatibility - Keyboard-navigable UI with audio cues and meaningful semantic labels - Documentation and developer guidelines for future accessibility improvements - Tested integration with Accessible-Coconut 24.04 This project will enable independent system installation for visually impaired users and contribute long-term value to Flutter-Linux accessibility efforts and the broader open-source community.
This project will improve how we store and analyze DNA sequence data by using ROOT's newer RNTuple format. We'll work in two main steps: First, we'll set up the current system and make it faster by improving search methods, processing data in batches, and using memory more efficiently. Then, we'll build a complete new system using RNTuple, which stores data in columns rather than rows. This includes creating tools to convert between common DNA data formats and RNTuple, splitting files in smart ways, and building fast search tools. Our goal is to make DNA data analysis much faster and able to handle the growing amount of sequence data that scientists are generating. This could become a new standard for DNA data storage that works better than current methods.
To address Apache DolphinScheduler's lack of generalized OIDC support which limited its adoption in enterprises that rely on a variety of identity providers like Keycloak, Okta, or Azure AD, this project introduces a new, pluggable, and configuration-driven authentication module. Built with Java and Spring Security, the backend handles the complete OIDC Authorization Code Flow, including automated user provisioning and role mapping based on IdP groups, all without requiring any database schema changes. The Vue.js frontend was enhanced to dynamically render login buttons for each configured identity provider. To ensure smooth onboarding and adoption, the project also delivers production-ready documentation with detailed setup guides for administrators and developers. The feature's quality is ensured by a robust testing strategy, featuring comprehensive unit tests and a full end-to-end API test suite using Testcontainers, which automatically orchestrates a Docker environment with DolphinScheduler and a Keycloak IdP to validate the entire login flow in a production-like environment. This project successfully delivers a production-ready Single Sign-On (SSO) solution that significantly enhances DolphinScheduler's security, usability, and enterprise-readiness.
Problem Statement: Sockstat is a useful FreeBSD utility for displaying active sockets, but its current output format is rigid and lacks flexibility. The -w option is a workaround to accommodate wide output, and the tool does not support structured data formats. Enhancing its user interface will improve usability and integration with modern tools. Proposed Solution: This project aims to improve sockstat by integrating libxo, which will allow structured output in multiple formats (JSON, XML, etc.). Additionally, the column sizes will be dynamically adjusted to enhance readability, eliminating the need for the -w option. Deliverables: -> Rewrite sockstat output using libxo for JSON, XML, and other formats. -> Implement automatic column sizing for better readability. -> Remove the -w option and replace it with a more intelligent formatting approach. -> Ensure backward compatibility and proper testing. This project will enhance sockstat’s usability while maintaining its lightweight and efficient design.
This project aims to enhance OpenMP support in LFortran by developing a unified ASR node, that encapsulates all core and advanced OpenMP directives and clauses. The new design will enable robust handling of constructs like Parallel, Do, Teams, Tasks, Distribute, and Target offloading, ensuring systematic lowering to runtime calls. Key deliverables includes modifying the current design of representing OpenMp directives in ASR and implementing it's features via runtime calls and explore Target Offloading support. This will make LFortran a more powerful and extensible tool for HPC applications.
CCExtractor’s last stable release (v0.94) came out in 2021, and since then, the codebase has undergone significant modifications, with several major pull requests still pending integration. To ensure a smooth transition to v1.00, this project will focus on finalizing these changes, ensuring all regression tests pass, updating the Flutter-based GUI, and automating the release process. By the end of this project, CCExtractor will be ready for its v1.00 release, featuring a stable and well-tested codebase, an up-to-date graphical interface, and a streamlined development workflow.
The Scrum Helper Chrome Extension project is about improving the way Scrum teams generate daily standup reports by making the process smoother and more efficient. My Google Summer of Code 2025 proposal with FOSSASIA focuses on key upgrades, such as adding support for multiple email providers (Gmail, Yahoo, Outlook), creating a standalone pop-up UI, improving GitHub data fetching, and making the extension faster and more user-friendly. I have already contributed by implementing multi-client email support and will now work on UI refinements, caching, and API improvements. My timeline includes refining the design, improving performance, testing, and writing clear documentation to ensure everything works well across different platforms. With experience contributing to open-source projects like Apache, NumFOCUS, and AI-Alliance, I am eager to continue working with the FOSSASIA community and making this tool more useful for Scrum teams.
Current deep learning models for CMS particle reconstruction are often task-specific. This project aims to develop versatile foundation models by pre-training deep neural networks on unlabeled CMS End-to-End (E2E) detector data using various Self-Supervised Learning (SSL) strategies (MAE, I-JEPA, CAE, VAE). These models learn robust, general-purpose representations of particle interactions. We will then comprehensively benchmark these foundation models by adapting them for diverse downstream tasks including Particle Identification (Classification), Kinematics Estimation (Regression), Detector Super-Resolution, and High-Fidelity Event Generation (investigating VAEs and conditional Diffusion Models). Deliverables include the open-source codebase with reproducible pipelines, pre-trained model weights, detailed benchmarking results/analysis, and user-friendly documentation.
While filleting is a common and essential modeling technique, its implementation in existing mesh processing libraries is often limited or absent. This project aims to address this gap by developing a robust and efficient polygon fillet algorithm specifically for the Manifold library. The initial phase of the project will concentrate on the 2D domain, with the goal of providing a user-ready implementation. Future work will involve extending this algorithm to support 3D mesh filleting.
The Form Engine (FDE) is a specialized module for the OpenMRS healthcare platform. Its primary purpose is to enable a natural and efficient workflow for entering multiple pre-recorded forms at once. It is specifically designed for retrospective data entry tasks and is not intended for use in real-time, point-of-care clinical workflows. For comprehensive details and guidance, please refer to the official FDE Wiki [https://openmrs.atlassian.net/wiki/spaces/docs/pages/150962486/Key+O3+Repositories#Fast-Data-Entry] Documentation. Objectives of the GSoC project: This project will enhance the React Form Engine to natively support the requirements of the Fast Data Entry (FDE) feature. The improved engine will then be used by FDE to deliver faster and more efficient patient data entry. A key objective is to maintain full backwards compatibility with the existing Angular Form Engine, ensuring that current implementations continue to function smoothly while enabling a seamless transition to the React-based workflow.
The Code Review Assistant app for Rocket.Chat addresses the common challenge of delayed code reviews, where pull requests often remain unattended for extended periods. This app intelligently analyzes the files modified in a pull request, examines the commit history of those files, leverages the CODEOWNERS file, and reviews past activity to identify the most relevant reviewers and does preliminary LLM review. By notifying only the most appropriate contributors, the app streamlines the review process. Integrated directly within Rocket.Chat, it provides user-friendly reminders and updates, LLM does the sanity review, enabling developers to stay informed and collaborate more effectively on code reviews.
Currently, SourceKit-LSP only shows the first line of the documentation for code completion items. Furthermore, it doesn’t support the Language Server Protocol’s (LSP) signature help request which provides information about the function or subscript being completed like alternative signatures, documentation, parameter list, and parameter-specific documentation. The goal of this project is to enhance how SourceKit-LSP displays documentation for code completion items by: 1. Providing the full documentation for code completion items rather than the first line only. 2. Implementing LSP’s signature help request to provide richer guidance for completing function/subscript signatures. The implementation will require changes in SourceKit-LSP and sourcekitd in the Swift compiler codebase. This will enhance the developer experience for Swift developers using SourceKit-LSP on editors like Visual Studio Code and Neovim aligning with Swift’s vision of cross-platform support.
This project will develop an intelligent chat interface for CellMinerCDB, a cancer genomics database, using GraphRAG (Graph Retrieval-Augmented Generation) to enhance accessibility for researchers. The system will convert natural language queries into executable R code and leverage knowledge graphs to provide context-aware responses about complex relationships between drugs, genes, and cancer cell lines. Key deliverables include: (1) A data bridge connecting R's CellMinerCDB with Python; (2) A GraphRAG component that builds and queries knowledge graphs from cancer genomics data; (3) NDEx integration for network visualization and sharing; and (4) A natural language interface powered by PandasAI. This project extends previous work by adding knowledge graph capabilities, improving entity recognition for cancer genomics terminology, and enabling standardized network sharing through NDEx. The completed system will democratize access to complex cancer genomics data, promote reproducibility in research, and establish a foundation for natural language interfaces to biomedical databases.
The Unicode Consortium maintains extensive locale datasets critical for internationalization tasks such as date/time formatting, text segmentation, measurement conversions, and collation. Manual verification of these datasets is challenging due to their vast scale. My project aims to address this by leveraging large language models (LLMs) to automate and enhance the validation of locale data. The approach involves designing targeted queries for an LLM, systematically comparing the generated outputs with existing CLDR/ICU datasets, and identifying discrepancies. These results will then be processed to isolate significant issues, and automated tools will be developed to flag potentially erroneous data for translators. Deliverables: 1.A robust pipeline for querying LLMs and generating locale data predictions. 2.Comprehensive comparative analysis between LLM predictions and CLDR/ICU datasets. 3.An automated issue detection and reporting mechanism integrated with existing Unicode systems. 4.Thorough documentation and guidelines for future dataset validation workflows.
This project focused on upgrading the existing pgwatch Grafana dashboards to ensure full compatibility with the latest Grafana version 12. While some dashboards had already been partially migrated, many still relied on outdated components and required manual refinement to ensure optimal performance. Grafana v11 had introduced significant changes, including the removal of AngularJS support and updates to panel JSON structures and transformation capabilities. With the release of Grafana v12, further enhancements and updates were made, making it crucial to migrate all dashboards to take full advantage of the new visualization features and capabilities. The primary objective of the project was to update the dashboards, ensuring they were fully functional with Grafana v12, while also improving usability and maintaining high performance. This involved not only updating the visualization elements to align with the new version but also addressing any deprecated components and optimizing the dashboards for a smoother user experience.In addition to the technical upgrades, the project included comprehensive documentation to guide future maintenance and ensure ease of future updates. This approach ensured the longevity and continued efficiency of the dashboards in a rapidly evolving Grafana ecosystem.
This project aims to create a dedicated web-based user interface for the workflows4s library to address the current lack of visual debugging tools. By building a full-stack solution with a ScalaJS frontend, the UI will enhance workflow development by allowing developers to visually inspect detailed workflow state at any point in history, clearly see the execution paths taken within a workflow diagram, and easily navigate the workflow's history using a timeline. Ultimately, this visual feedback will make understanding, developing, and debugging complex workflows significantly more accessible and intuitive compared to relying solely on logs.
DATA Spaces FrontEnd For Liquid Galaxy is a project designed to enhance data visualization using Liquid Galaxy, an immersive multi-screen system. This project will provide an interactive and scalable solution for displaying real-time or synthetic data retrieved from Fiware. The main goal is to create a Flutter App that allows users to select, filter, and visualize urban and environmental data on Liquid Galaxy.
The Mifos Gazelle Profile/Demo Creator project aimed to improve the deployment experience and simplify environment configuration for demonstrations and storyboarding. The main deliverable was a sophisticated demo-creator tool that allows organizations to set up Mifos Gazelle with custom deployments and create tailored demo data files for specific use cases and scenarios
This project aims to modernize the HPX parallel computing library by introducing C++20 Modules, addressing compilation performance and code organization challenges. I develop a comprehensive conversion strategy using a Python-based tracking system to analyze dependencies, create module interfaces, and ensure backward compatibility. The project will deliver a modularized HPX library with improved build system integration, enhanced symbol visibility, and detailed documentation, ultimately providing developers with a more efficient and maintainable parallel computing framework.
The goal of this project is to develop a fully configurable Android Virtual Printer application that simulates real printer behavior using the Internet Printing Protocol (IPP). This tool will allow developers, QA engineers, and ChromeOS/Android teams to debug and test printing workflows without requiring physical printer hardware. The app will function as an IPP-compatible printer on the network, responding to print jobs, processing documents, and allowing users to configure printer capabilities by uploading or directly retrieving IPP attributes from real printers. It will also support advanced features like print job simulation, plugin-based behavior injection, and exportable logs for deep debugging. This virtual printer will empower developers to reproduce and fix complex bugs, simulate diverse printer setups, and even integrate testing in CI pipelines — all through a user-friendly Android app. By combining protocol-level accuracy with intuitive design, it offers a powerful emulation environment for printer-related development and troubleshooting.