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.
Open World Holidays Framework is a powerful and flexible open-source Python framework designed to provide accurate and reliable public holiday data for over 150+ countries, regions, and local entities worldwide. I would like to add support for more countries to the Open World Holidays Framework to make it more useful.
SwitchMap-NG currently faces scalability challenges in distributed networks, including data loss due to unreliable connections and slow polling when monitoring thousands of devices. My proposed solution introduces a layered architecture: regional hubs will collect device data from edge pollers, buffer it locally during outages, and forward it to a central server. To improve performance, I’ll implement asynchronous polling, decouple frequent performance updates (e.g., every 5 minutes) from less frequent status checks (e.g., hourly), and introduce historical data tracking along with new device metrics like CPU, memory, and power usage. The final deliverables will include a fully containerized deployment alongside local buffering, complete testing, automated documentation. This will significantly improve the reliability, speed, and scalability of SwitchMap-NG, making it better suited for large-scale network monitoring and management.
This project implements hpx::system_scheduler as a P2079-compliant parallel execution context for HPX, mapping tasks to hpx::threads for scalability and performance. The scheduler aligns with P2079 and P2300’s Senders/Receivers, optimizes bulk scheduling, and ensures thread safety. It includes a user-facing API with get_parallel_scheduler() for parallel task scheduling, link-time replaceability via system_context_replaceability for custom backends, and bulk unchunked execution processing items individually with execute(i, i+1) calls. The plan comprises four phases: scheduler development, performance optimization, Senders/Receivers integration, and testing/benchmarking.
I propose to make an intelligent assistant that acts as a personal pregnancy planner and guide, ensuring that expecting parents stay informed, organized, and stress-free. It is every expecting mother’s private, smart and offline-first companion. I plan to implement the following goals 1. Scraping and storing country-specific healthcare guidelines for pregnancy 2. Create a RAG agent for handling appointments and task 3. Build notification and reminder system for appointment management 4. Store the required data in SQLite 5. UI Revamp for the app creating a responsive, personalized and interactive front end 6. Add Voice Assistant Functionality to give users a hand-free experience 7. Improving the accuracy and response time of the chat bot 8. End to end testing of the entire app 9. Back end Integration and then deployment Deliverable - An AI powered companion that is capable of automated tracking of trimester-specific medical appointments, sending country-specific healthcare requirement notifications, have offline access to pregnancy care guidelines, giving personalized recommendations and reminders.
The ZOO-Project is an open-source WPS (Web Processing Service) platform. The propose of this proposal is to reorganize and improve the ZOO-Project CWL runner ecosystem by creating a unified and modular repository structure. The goal is to make the code for existing CWL runners (EOEPCA, Argo Workflows, Calrissian) more generic, facilitate the addition of new runners, and provide clear documentation. Proposal's plan includes using abstract classes to reduce code duplication, enhancing the entry point logic, and ensuring compatibility with ZOO-Kernel and CWL standards.
POSIX Issue 8, released in 2024, introduces several additional APIs that improve standardization, portability, and functionality across compliant operating systems. This project aims to analyze, implement, and test missing APIs from POSIX Issue 8 in the RTEMS real-time operating system.
The KDE Print Manager, a critical component of the KDE desktop environment, requires updates to support the advancements introduced in CUPS 3.x. This project aims to modernize the Print Manager by enabling compatibility with CUPS 3.x while maintaining backward compatibility with CUPS 2.x. The focus will be on incorporating support for IPP (Internet Printing Protocol) print destinations, which allow users to print to driverless network printers, IPP-over-USB printers, and Printer Applications without the need for traditional CUPS queues or PPD files.
This project aims to integrate AI agents with Knative Functions by developing a MCP server that allows to dynamically create and deploy functions using natural language prompts via MCP-compatible clients.
Various Rust repositories under the rust-lang organization use a merge queue bot, bors, for testing and merging pull requests. This project aims to complete the remaining functionality required to make the new bors bot usable on the rust-lang/rust repository, replacing the legacy bot homu. This includes implementing PR merges, rollup support, and the queue website.
Checkstyle is widely used to detect code style violations, but many of its formatting-related issues are trivial and time-consuming to fix manually. This project aims to introduce an auto-fix module that can automatically correct formatting violations reported by specific Checks. The work involves evaluating existing auto-fix tools and libraries (e.g., OpenRewrite, CleanThat), selecting or building a reliable code modification engine, and designing an API for triggering code changes. A set of fixable formatting Checks will be selected, and their fix logic will be implemented in a maintainable way. The module will also include logic to prevent conflicting fixes and, if successful, may be proposed for integration into Checkstyle’s core to support plugin reuse.
Researchers have tremendous difficulty keeping up with the exponential growth of scientific literature, hindering their ability to stay on top of the latest insights in their field. This is especially true in quantum physics, where groundbreaking findings and complex concepts are emerging at a rapid pace, demanding constant attention and analysis from researchers. There is a dire need for AI that can efficiently process and summarize these vast volumes of scientific papers, helping human researchers focus their efforts on the most promising areas of investigation. The problem of knowledge overload and the need for efficient systems to navigate and synthesize vast amounts of literature is not unique to quantum physics. In fact, it is a pervasive challenge across various academic and scientific disciplines, including statistics and data science – the very fields that led to the development of large language models (LLMs) and retrieval-augmented generation (RAG) models. The exponential growth of research papers, coupled with the rapid advancement of statistical methodologies and data-driven approaches, has created a significant knowledge bottleneck in these domains. Researchers and practitioners in statistics and data science often struggle to keep up with the latest developments, hindering their ability to effectively leverage cutting-edge techniques and methodologies in their work. This knowledge overload problem has motivated the development of AI-powered systems like LLMs and RAG models, which aim to streamline the process of knowledge discovery, synthesis, and dissemination. By adapting the proposed "AI Scholar" system to the domains of statistics and data science, researchers in these fields could benefit from personalized recommendations, automated literature analysis, and idea generation capabilities, ultimately accelerating the pace of innovation and fostering cross-disciplinary collaboration.
The Large Hadron Collider (LHC) hosts high-energy physics (HEP) experiments, such as ATLAS, which generate over 1 petabyte of data every second. However, due to bandwidth and storage limitations, only a fraction of the produced data can be stored. To ensure that CERN’s scientists can benefit from having as much data as possible, lossy compression techniques can be considered as a possible solution to CERN’s high data volume challenge. A promising contender in data compression techniques is “BALER,” a machine-learning-based compression tool under development by the particle physics divisions of the University of Manchester. Through the utilization of autoencoder neural networks, significant levels of compression while maintaining high accuracy have been achieved for a variety of datasets, including highly-dimensional LHC datasets and 2D images. Through Google Summer of Code 2025, I plan to collaborate with HSF, Manchester, and BALER to enhance their current compression model, tailoring it for physics-specific experimental data, enabling high-fidelity reconstruction for scientific investigation and analysis. Specifically, I plan to implement a physics-informed autoencoder model and evaluate its performance on open LHC datasets. Leveraging my past experience with Tensorized Physics-Informed Neural Networks, I aim to integrate physical laws directly into the autoencoder architecture and loss function, ensuring that compressed representations maintain physical validity. Furthermore, comparing reconstructed data against the original collected data will highlight outliers and physical abnormalities. Finally, I plan to document all experiments and evaluate the physics-informed autoencoder against BALER’s current performance when compressing real-world physics experiment data. With aid from my mentors, I hope to deploy this specialized version of BALER’s tool for CERN and other groups who could benefit from powerful physics-aware data compression.
Problem: Traditional ArUco markers in OpenCV struggle with occlusion and long-range detection. Fractal ArUco markers (developed by Prof. Rafael Muñoz Salinas and team) address these limitations through nested designs but are not yet integrated into OpenCV. Solution: 1. Replace the current picoflann dependency with OpenCV’s native FLANN module (kdtree_single_index). 2. Benchmark both implementations for accuracy, speed, and memory efficiency. 3. Integrate the optimal solution into OpenCV, ensuring backward compatibility and performance. Deliverables: 1. Fractal ArUco integration in OpenCV 2. Documentation (API references, tutorials, performance guidelines) 3. Merged OpenCV pull request with tests and examples
optimagic is a optimization library which aims to provide a unified interface to optimizers from SciPy, NlOpt and many other widely used packages. This project aims to add more optimizers specifically from ensmallen, PRIMA, Nevergrad, Bayesian Optimization, Knitro and if possible, others. I will implement each particular optimizer, reading the literature and official documentation related to each optimizer, and keeping in mind optimagic's core idea. The main goal is to wrap as many optimizers as possible, giving them a consistent interface with optimagic's minimize function. For users, this will mean more freedom while choosing and comparing optimizers that best suits their needs. This will involve writing well-tested code, tests, and benchmarking to further improve performance. Also, I will write documentation, how-to-guides and example notebooks to guide users using the library.
The goal of this project is to parallelize the CGAL Tetrahedral Remeshing package using the Intel Threading Building Blocks (TBB) library. This will significantly reduce the computational time required for remeshing large meshes, enabling faster and more efficient simulations. CGAL already provides some parallel implementations for some of its packages. While the primary focus is to parallelize the Remeshing package, a key objective is to lay the foundation for a generic parallelization framework for CGAL. Analogously to C++ STL's execution policies we would like to develop a framework that could, as future work, be extended to the rest of the library and allow to seamlessly change execution policies. The core of this proposal is a generic framework for the parallel execution of atomic operations using TBB in the remeshing package.
The torch ecosystem is rapidly growing in R, but it still lacks support for several key computer vision capabilities available in Python's torchvision package. This proposal aims to close the gap by implementing a wide range of torchvision datasets and models directly in R. Specifically, the project will: Implement all torchvision datasets. Add support for 5 key computer vision tasks: Object Detection, Instance Segmentation, Keypoint Detection, Semantic Segmentation, and Quantized Models. Provide native R implementations that don't rely on Python bindings, making it easier to install and use. Deliverables include tested R implementations of datasets and models, documented APIs, and example use cases. This will make R a more viable option for computer vision research and production.
This project aims to implement essential Git operations in GitLab's Web IDE, eliminating inefficient repository cloning for common version control tasks. The project will add commit amend, force push, stash, and rebase functionality. Implementation will proceed methodically, beginning with features requiring no backend changes before addressing REST API modifications. These enhancements will significantly improve developer productivity by enabling complete Git workflows within the browser, bringing Web IDE capabilities closer to VS-Code source control.
This project proposes the development of faust2clap, a tool that integrates the Faust programming language with the CLAP (CLever Audio Plugin) standard. Faust is a high-level functional language for real-time DSP, while CLAP is a modern open-source plugin format gaining traction as an alternative to VST and AudioUnit. Currently, Faust does not officially support CLAP as a target architecture. The goal is to extend the existing faust2xx framework by implementing a CLAP architecture file and a new command-line utility, faust2clap. This will allow developers to compile Faust DSP code into fully functional CLAP plugins, supporting advanced features such as per-note modulation and sample-accurate automation. Deliverables include the tool itself, a reusable architecture backend, a suite of test plugins, and comprehensive documentation. The project has been developed in close collaboration with the Faust team and aims to be merged upstream as an official component of the Faust toolchain. By bridging Faust and CLAP, this project supports open plugin standards, expands deployment options for DSP developers, and modernises the Faust ecosystem.
This project focuses on end-to-end Handwritten Text Recognition (HTR) for early modern Spanish manuscripts. Unlike traditional OCR systems, which process isolated characters or lines, end-to-end HTR captures entire documents, preserving not only the text but also structural elements such as layout and reading order. Although this approach holds significant promise for both research and practical applications, it remains underexplored, especially for historical texts. This project proposes to apply end-to-end HTR techniques to early modern Spanish manuscripts, a historically rich yet computationally challenging corpus. Leveraging recent advances in deep learning. The project aims to improve recognition accuracy on handwritten and printed texts from this period by building on models which focus on document-wide attention mechanisms, the system will be able to better handle complex layouts and diverse handwriting styles typical of early modern Spanish texts. Ultimately, this research sits at the intersection of machine learning and historical document analysis, contributing both to technical innovation and cultural preservation. By improving the accessibility of early Spanish documents, the project not only supports scholars in the humanities but also contributes to the growing field of AI-driven humanities research. The integration of cutting-edge HTR models into historical workflows can open new possibilities for indexing, searching, and analyzing large volumes of archival material in a scalable, automated fashion.
This project will enhance Makim by implementing Language Server Protocol (LSP) support for its YAML configuration files. This will introduce features like autocompletion, syntax validation, hover documentation, and custom commands directly within code editors. The project will deliver a Language Server and a VS Code extension, significantly improving the developer experience and making Makim more user-friendly.
Problem: Embedded Linux systems, particularly for In-Vehicle Infotainment (IVI), lack a user-friendly, secure application store that matches the seamless experience of mobile platforms. Existing solutions often fall short in providing curated app access, robust security, and support for diverse app types, limiting their adoption in production-ready environments. Solution: The Flatpak App Store addresses this by delivering a modern application store for embedded Linux. Built with Flutter for an intuitive UI, it leverages Flatpak for secure, sandboxed app distribution and integrates advanced features like MutualTLS, DRM playback, and Android app support via crosvm. A 22-week implementation plan ensures a scalable, production-ready solution, with cloud APIs for app management and user reviews, tailored to IVI use cases. Deliverables: A fully functional Flatpak App Store application with browsing, installation, and review capabilities. Secure architecture featuring MutualTLS, sandboxing, and secret storage. Support for Flutter, Native Linux, and Android apps, with DRM playback integration. Packaged Flatpak app and repository setup for deployment. Comprehensive documentation and test suite for IVI production readiness. This project will empower embedded Linux users with a reliable, mobile-like app store experience, enhancing IVI system functionality and security.
Kolibri's current Windows installer is outdated, difficult to maintain, relies on the unsupported IE11 engine, and lacks parity with the modern kolibri-app used on macOS. This project aims to replace the legacy installer by enhancing the existing Python-based kolibri-app to provide a first-class experience on Windows. The solution involves integrating the Microsoft Edge WebView2 engine, implementing native Windows features such as background operation via a Windows Service (using pywin32) and a system tray icon (wxPython), and creating a new native installer using InnoSetup. The application architecture will separate the UI and server processes for robustness. An automated build pipeline using GitHub Actions will be developed to produce the application bundle (via PyInstaller) and the final installer package, including code signing for releases. Main deliverables include: a functional Kolibri Windows application built from the kolibri-app codebase, a native InnoSetup installer (.exe), system tray functionality for server management, reliable background operation via a Windows service, seamless WebView2 integration, and an automated GitHub Actions build workflow for Windows artifacts.
The proposed solution introduces comprehensive tracing capabilities to the LLM4S toolkit by integrating OpenTelemetry (otel4s) for capturing detailed spans and metrics during LLM operations such as prompt construction, model invocation, and response parsing. These telemetry signals are exported in Prometheus and Jaeger-compatible formats and processed through the OpenTelemetry Collector. The data is then visualized on a unified Grafana dashboard, allowing developers to monitor performance, debug errors, and analyze execution flows across different LLM providers in real-time.
This project aims to enhance the data download capabilities of the Center for Translational Data Science's Python SDK & CLI by implementing robust, efficient, and user-friendly functionality for researchers to download and stream large biomedical datasets. By integrating with Globus for secure data transfer and optimizing performance through asynchronous processing, this implementation will significantly improve the research workflow for scientists working with large-scale biomedical data. The proposed solution will focus on maintaining high code quality through comprehensive testing, ensuring a seamless user experience, and optimizing performance for handling large datasets. The end result will be a reliable tool that enables researchers to efficiently transfer data to their workspaces for analysis, ultimately accelerating scientific discovery in the biomedical field