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.
FS2, a functional streaming library for Scala, currently utilizes blocking I/O operations, resulting in performance bottlenecks such as context switching and resource contention, particularly in high I/O-bound workloads. To overcome this, the project proposes reimplementing I/O APIs specifically Unix sockets, datagram sockets, and processes by leveraging polling-based mechanisms introduced in Cats Effect v3.6.0, which will remove the reliance on dedicated dispatcher threads and eliminate inefficiencies tied to blocking calls. This reimplementation will support JVM selector-based polling and Native file descriptor polling, while keeping existing implementations as fallbacks for runtimes that do not support the new approach therefore ensuring backward compatibility. The project will deliver these reimplemented APIs alongside comprehensive test suites to verify correctness, performance benchmarks to quantify improvements, and updated API documentation to ensure usability. By improving FS2’s efficiency and scalability, this enhancement will strengthen the Typelevel ecosystem and provide high-performance streaming library tailored for modern applications.
The Juice Shop CTF Tool, currently made with vanilla JavaScript, needs to be upgraded to TypeScript to align with the main project for easier maintenance. Also, its code quality should be improved by applying Juice Shop's ESLint standards. The project's tests coverage and relevance should also be reviewed and strengthened where necessary . Furthermore, several other sub-projects like Juicy Statistics, Juicy Coupon Bot , Juicy Chat Bot should also be renovated
This project focuses on extending the R interface of the torchvision library by implementing support for core computer vision datasets and model architectures. The scope includes adding native loaders for widely used datasets such as COCO and VOC, along with support for key models including Faster R-CNN, Mask R-CNN, FCN, Keypoint R-CNN, and quantized ResNet variants. The proposed work enhances the torch ecosystem in R by enabling advanced computer vision workflows with consistent APIs, GPU compatibility, and clean documentation. The implementation will follow package development best practices with robust testing, reusable components, and user-friendly examples. The resulting contributions aim to reduce the gap between R and Python in deep learning tools, enabling R users to build scalable, efficient, and modern vision pipelines.
This project aims to improve the testing framework for IntelOwl analyzers by transitioning from the existing monkeypatch-based approach to a more structured unit testing strategy using Python’s unittest framework. The project will be executed in three phases. The first phase will focus on creating a prototype of the new testing model, implementing unit tests for a few analyzers. The second phase will involve writing unit tests for all analyzers and removing monkeypatching. Finally, in the last phase, we will document the new testing system to ensure clarity and ease of use.
OpenSCAD currently supports Windows development/build setup through 2 key ways: MSYS2 and MXE. A MSVC based build has instructions circa 2012, but with significant changes in project structure, and updated/new third party libraries and dependencies, it would be useful to work on adding modern MSVC build support for Windows. Currently, most CI builds use MSYS2 instructions, which has a Unix style build system. The benefits of adding support for MSVC builds include having executable and library outputs (.exe/.dll), vcpkg support for third party libraries OpenSCAD depends on, and support for parallel builds for speed.
The Jaya R package implements the Jaya optimization algorithm, a gradient-free, population-based method for solving both single-objective and multi-objective optimization problems. The Jaya algorithm, introduced by Rao in 2016, has gained attention for its simplicity and effectiveness, as it requires no hyperparameter tuning, making it particularly useful for users who need fast and reliable optimization solutions. However, while the current version (1.0.3) of the Jaya package is functional, there is significant room for improvement in terms of computational efficiency, usability, and integration with the broader R ecosystem. This GSoC project proposes a major upgrade to the Jaya package with the goal of improving algorithmic performance, enhancing parallel computation capabilities, and expanding the package's compatibility with widely-used R tools. Additionally, the project aims to make the package more user-friendly by streamlining the interface and improving documentation. These updates will help integrate Jaya into modern optimization workflows, benefiting researchers, practitioners, and educators alike.
This project implements key components of KEP-2170, introducing the Kubeflow Training V2 API. Specifically, it focuses on creating the TrainingRuntime and ClusterTrainingRuntime for the JAX and TensorFlow frameworks, built upon the Kubernetes JobSet API. These runtimes will serve as blueprints for model training (including LLMs) within cloud-native ML pipelines. This abstraction allows Data Scientists and MLOps Engineers to easily reuse standardized runtimes and launch training jobs, particularly via the SDK, without needing deep knowledge of underlying Kubernetes complexities.
This project successfully developed two AI-powered tools to enhance software quality at Eclipse Adoptium. The first, GlitchWitcher, implements the REPD (Reconstruction Error Probability Distribution) model, using an autoencoder for supervised anomaly detection to proactively predict software defects. The project's primary deliverable evolved into VitAI, an advanced, modular multi-agent AI assistant for interactive test triage. VitAI's architecture features a custom MCP (Model Context Protocol) server for providing an interface to interact with a specialized agent and a Retrieval-Augmented Generation (RAG) system. The RAG system provides deep, context-aware responses by querying a vector database of project documentation, issues, and build data. This work was supported by automated data pipelines and is showcased in a live interactive demo.
The HITEMP CO₂ spectroscopic database is extremely large and inefficient to work with. The distributed file is about 6 GB when compressed, but expands to nearly 50 GB upon decompression. The existing workflow requires fully decompressing and batch-parsing the entire file, an operation that takes close to 2.5 hours and consumes significant disk I/O, memory, and network bandwidth. This full-decompress/parse approach forces users to rely on large, high-speed storage, makes quick exploratory analysis or iterative development impractical, and wastes both bandwidth and time when only a small subset of the data is actually needed. This project addressed the problem by implementing a partial download mechanism, where only the required data chunks are downloaded, decompressed, and parsed based on user queries. The parsed results are then cached for reuse. For performance, the cache parsing was accelerated using a C++ SIMD (Single Instruction, Multiple Data) parser optimized for AVX2 architectures, while for other architectures the system falls back to an optimized Python vectorized parser.
The Temporary Road Closures Database and API project addresses a critical gap in the OpenStreetMap (OSM) ecosystem by creating a centralized, real-time database and web service to manage temporary road closures caused by construction, accidents, and events. The system will leverage PostgreSQL for robust geospatial data storage, provide a RESTful API using FastAPI with OpenLR standard for universal compatibility, and include a user-friendly web interface for community submissions and real-time closure viewing. Additionally, a prototype integration with the OsmAnd navigation app will demonstrate practical utility by enabling dynamic routing adjustments around closures. By project completion, deliverables will include a functional database, API, web interface, and a demonstrable OsmAnd integration, significantly enhancing routing accuracy and safety for OSM users.
The CernVM File System - CVMFS distributes LHC experiment software and conditions data to the LHC computing infrastructure. The client application is a read-only filesystem in userspace - a FUSE module, and may be sensitive to the different versions of linux kernel. Currently the integration test suite of CVMFS is run on different linux distributions and platforms and has coverage over a handful of kernel versions. The goal of this project is to increase this coverage and allow systematic testing for specific kernel versions and features.
This proposal aims to add support for Malayalam in the Unicode Inflection project, which is important for ensuring accurate automated text formatting and grammatical correctness in multiple languages. Currently, Malayalam is not supported, despite being spoken by over 35 million people, primarily in Kerala, India. The project will involve extracting data from Wikidata, creating inflection rules, implementing these rules in C++ and C, and conducting testing to ensure accuracy. The expected outcome is to enable correct grammatical inflections for Malayalam nouns, pronouns, verbs, adjectives, and adverbs, improving tools such as chatbots, automated translation, and assistive technologies. The project will benefit Malayalam speakers worldwide by improving communication tools and making the language more accessible in computer applications.
This project aims to integrate Radio-Browser.info into VLC Media Player, allowing users to browse and play internet radio stations directly within VLC. The implementation will use the free Radio-Browser API, eliminating the need to manually search and paste stream URLs.
The project enhances the IYP Browser to make the exploration of graph data more interactive and powerful. It introduces features such as node expansion on click, expandable graph views, and smart Cypher query suggestions relevant to actual IYP data. The researchers and stakeholders will benefit from improved UI controls, shareable and embeddable components, and URL-based cypher query execution. These new features will help the researchers explore and analyze networked data, get deeper insights, and make informed decisions.
This proposal outlines the development of an AI Agent for Apache HertzBeat using the Model Context Protocol (MCP), enabling natural language interaction with monitoring capabilities. The project will implement an MCP-compliant server and client architecture integrated with SpringAI, along with a chat-based frontend for the HertzBeat dashboard. This enhancement will make HertzBeat's monitoring features more accessible while serving as a reference implementation for AI integration in monitoring tools.
This project aims to test the performance of |toqito⟩ and compare it with other quantum computing libraries. It is divided into three parts: (1) Comparing |toqito⟩ with libraries like PennyLane, Qiskit, etc. by running standardized tests inside Docker to ensure consistency across different computers; (2) Automatic benchmarking using GitHub Actions, where performance tests run on every update and results are stored for analysis; and (3) Identifying slow parts of |toqito⟩ using cProfile, focusing on operations like matrix calculations, quantum measurements, and random object generation. ------------------------------------------------------------------------------ Deliverables include: 1. A new benchmark/ folder in |toqito⟩ that can run and store benchmarks, including support for running them in Docker. 2. A system to track |toqito⟩’s performance over time using monthly benchmarks or we can choose to run only relevant benchmarks after each merged PR. 3. Found and suggested improvements for slow parts in at least one full module of |toqito⟩.
This project aims to extend OpenCV’s DNN module with efficient runtime support for Large Language Models (LLMs), focusing on enabling Visual Language Models.
This project addresses the challenge of enhancing Glutton's protocol parsing capabilities by implementing HTTP and DNS parsers using Spicy, a specialized domain-specific language for robust protocol parsing. The existing Go-based protocol handlers in Glutton will be reimagined through Spicy's grammar-based approach, creating parsers that precisely match the current implementation's behavior, including special case handling for attack vectors like Ethereum RPC exploits and Hadoop YARN vulnerabilities. The project involves the creation of a Go wrapper framework to integrate these Spicy-generated parsers with Glutton's architecture and the delivery of fully functional HTTP and DNS parsers. This work will demonstrate how specialized grammar-based protocol parsing can enhance Glutton's maintainability and extensibility while maintaining its effectiveness as a protocol-agnostic honeypot for security research.
PostgreSQL extensions can offer detailed views of query performance, storage usage, and system health but this would need frequent manual setup to be used with monitoring systems. Our proposal improves upon pgexporter through automatic detection of supported extensions and the output of pre-configured metrics for vital extensions such as pg_stat_statements, pg_buffercache, and pg_stat_monitor. It allows easy observability, diminishes the role of manual setup, and helps for optimal data-driven database performance monitoring.
The project aims to compute the Poincaré normal form of Riemann matrices in SageMath. This computation enables the decomposition of theta functions into a product of lower-dimensional theta functions, which can be evaluated much faster. The project will implement the methods described by Martens to equip SageMath with tools for detecting and performing these reductions. The solution involves finding the reduction matrix M (if it exists), computing the Poincaré normal form of M, and applying a transformation to the period matrix. We aim to deliver a SageMath module for computing M and its normal form, a function for transforming the period matrix, a fully tested implementation for Poincaré reduction, and comprehensive documentation.
MQTT is a lightweight messaging protocol which is used by IoT based devices as a way to transfer data at very high speeds. Adding its support to ERDDAP™ would enable it access near real time data and build datasets with it. This project will add support for ERDDAP™ to act as both, an MQTT client to connect with existing brokers and as an MQTT broker to collect real time data from sensors.
The Greybus module for Zephyr currently exists as an out-of-tree component, making maintenance, testing, and contributions difficult. This project aims to upstream Greybus as an official Zephyr module, improving maintainability, accessibility, and seamless integration within the Zephyr RTOS ecosystem. By upstreaming Greybus, BeagleConnect and other Greybus-enabled platforms will gain native support in Zephyr, removing the need for custom patches or kernel modifications. Originally developed by Google as part of Project Ara, Greybus is a lightweight, high-speed protocol designed for efficient, low-power communication across diverse hardware interfaces. While initially intended for modular smartphones, Greybus has since expanded into IoT and industrial applications, particularly in wireless sensor networks. This project will focus on cleaning up and refactoring the existing Greybus module, revamping its testing infrastructure, and ensuring compatibility with Zephyr’s CI/CD workflows. The successful completion of this work will enable seamless hardware-software interaction, making Greybus more accessible for embedded systems development within Zephyr.
This project proposes to enhance Clad, a Clang-based automatic differentiation (AD) tool, with support for NVIDIA's Thrust library. By enabling differentiation of Thrust's GPU-parallel algorithms, Clad users will gain the ability to automatically generate gradients for CUDA-accelerated code in scientific computing and machine learning applications. The implementation will include extending Clad's source-to-source transformation engine to recognize Thrust primitives (e.g., transform, reduce), implement custom derivatives, and validate performance through real-world use cases. This work will bridge the gap between high-performance GPU computing and AD, potentially accelerating gradient-based optimization tasks by orders of magnitude.
The OSIPI initiative has developed various open-source tools for quantitative MRI, particularly in perfusion imaging. However, the documentation for these tools is currently fragmented across multiple projects, each with different structures, styles, and rendering approaches. This inconsistency creates barriers to usability, maintainability, and accessibility. This project aims to unify OSIPI’s documentation under a single, standardized HTML framework. By utilizing modern documentation tools such as MkDocs or other static site generators, we will create a consistent, searchable, and user-friendly interface. The unified framework will streamline maintenance, improve accessibility, and enhance the overall user experience. Deliverables include: A standardized template for OSIPI documentation. Migration of existing project documentation into the new framework. Integrated navigation and search functionality across all documentation. Automated deployment pipeline using GitHub Pages or similar tools. Clear documentation and contribution guidelines for future scalability.