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.
Gigaflow is an innovative solution to accelerate network processing in large-scale data centers by leveraging flow locality and pipeline-aware caching, offloading processing to SmartNICs. Currently, it supports only Alveo U250 FPGAs, limiting its versatility. This proposal aims to extend Gigaflow’s backend support by developing new APIs for flow integration, enabling compatibility with Pensando DPUs. Additionally, the current implementation of Sub-Treversal Partitioning (STP) incurs high CPU overhead during startup, minimizing the system's performance benefits. This project will optimize STP to reduce CPU usage and improve startup efficiency. Finally, Gigaflow’s newness requires further optimization in the compilation, LTM, and driver pipeline, alongside additional testing for alternative strategies for priority selection and rule deletion. The proposal will address these challenges. By achieving these goals, the project will streamline Gigaflow caches in the OVS backend, facilitating more efficient and flexible solutions for modern data centers.
This project aims to improve CircuitVerse by adding new components that are useful for learning about real hardware, such as shift registers (SISO, SIMO, MISO, MIMO), comparators, and a buzzer (speaker), Priority MUX, etc. It will also introduce support for connecting CircuitVerse with real devices using the Browser’s Web Serial API, allowing users to interact with physical hardware directly through the simulator. These features will help people better understand how digital circuits work—both in theory and in practice. The goal is to make CircuitVerse more powerful and helpful for learning digital circuits and embedded systems.
FRM files are what MariaDB uses to store metadata about tables. These files can be used to generate DDL statements (CREATE TABLE ...). We are lacking a utility to parse these files which could in turn make DBAs lives easier. The task of this project is to have this utility implemented, making use of MariaDB's FRM parsing logic. You may have to carry out some refactoring to extract the parsing code into a reusable library, once for MariaDB Server, once for the FRM parsing tool.
This project addresses the need for enhanced usability and learning resources within the toqito quantum information library by creating a user-friendly example gallery, inspired by successful models like scikit-learn's. The core problem is the current lack of diverse, executable examples demonstrating toqito's capabilities in practical scenarios. The proposed solution involves developing the gallery's web infrastructure (potentially using Sphinx-Gallery) integrated into toqito's existing documentation, and populating it with high-quality, self-contained Python examples. Key deliverables include the functional gallery structure and 6 core examples demonstrating crucial toqito functionalities: modeling cryptographic protocols (Bit Commitment, QKD QBER) using ExtendedNonlocalGame, verifying state antidistinguishability thresholds from recent literature using the state_opt module, and illustrating channel properties (is_extremal) using channel_props. This gallery will significantly improve toqito's accessibility for researchers and new users, providing practical code and explanations for core quantum information concepts.
This project proposes integrating NVIDIA's Thrust parallel algorithms library with HPX to enable GPU acceleration while maintaining consistency with HPX's existing parallel algorithm interfaces. The solution involves creating a specialized Thrust executor that extends HPX's CUDA executor capabilities, implementing automatic memory management for data transfers between host and device, and developing a dispatching mechanism that selects the appropriate backend (CPU or GPU) based on execution policies. Key technical components include a version-aware API layer to handle Thrust compatibility, exception handling that bridges Thrust/CUDA errors with HPX's error system, and template-based algorithm overloads that transparently route calls to Thrust implementations when GPU execution is requested. The implementation will proceed through four phases: establishing core infrastructure (executor, memory management), integrating fundamental algorithms (transform, reduce, sort), adding HPX execution policy support, and concluding with comprehensive testing and optimization. The resulting system will allow developers to write single code paths that automatically leverage GPU acceleration through Thrust when available, all while maintaining HPX's asynchronous execution model through future-based interfaces.
This project aims to enhance the functionality and user experience of web tools, starting with the Hardware Report Tool and UAV Log Viewer, by integrating an AI-powered assistant. The assistant will provide context-aware responses using Retrieval-Augmented Generation (RAG) and execute actions within the tools through function calling. Deliverables include: 1. AI-powered chat interface integrated into the Hardware Report Tool and UAV Log Viewer. 2. RAG implementation for accurate, context-aware responses. 3. Function calling capabilities, enabling AI to execute tool-specific actions. 4. Automated assistant setup for easy integration with future web tools.
I would like to work with the Open Library team to create a plugin within the Internet Archive’s book reader app that would enable users to locally translate books and integrate the translated text to allow text-to-speech functionality for different languages. Using JavaScript and the Bergamot Translation model, this feature will parse the transparent text layer within the IA's book reader, feed the input into the translation model, and output the translated text onto the app. Using a simplified calculation of books available for lending within the Open Library catalog, this project would expand the 3 million works available in English to at least 18 million titles across the 6 different languages supported by the Bergamot project, directly contributing to the Open Library's 2025 goal of offering more with less. The primary deliverables for this project can be broken down into two major parts: implementing a translation plugin that allows users to select the source + target translation languages and intercepting the existing text-to-speech plugin to read the translated output from the Bergamot translation model. A future high-level deliverable for this project would allow volunteers to contribute their own translations for texts, which could allow higher quality translations to be provided to fellow patrons.
This project proposes an AI-powered accessibility auditing and remediation toolkit tailored for Drupal environments. It integrates automated accessibility scanners (e.g., Deque Axe API), and NLP models (such as GPT-4 or BLIP-2) to suggest intelligent alt-text and identify layout/media accessibility issues. A dynamic dashboard will be built to track scan results, remediation progress, and generate compliance documentation in formats like PDF and CSV. The system will be developed using Symfony (backend), HTML+Twig (frontend templating), and MongoDB (for storing audit results and history). Key components include API communication layers, a feedback system for rating AI suggestions, and tight workflow integration with Drupal, enabling accessibility checks before content is published. The architecture emphasizes modularity, ethical AI use, and compatibility with WCAG standards.
This project focuses on modernizing the LibreOffice Impress slideshow rendering system by replacing the older metafile-based approach with a more streamlined and modern rendering path using DrawingLayer primitives. The goal is to render slide content directly onto the screen without relying on canvas abstractions. This involves integrating the DrawingLayer’s primitive processing into the slideshow engine, handling both static and animated content, and gradually moving relevant rendering logic into the core VCL module. Additional work was done to ensure animation effects, including GIF playback and text-based animations, are correctly supported with primitives. The result will be a cleaner, more maintainable rendering architecture.
This project aims to develop a comprehensive Hamiltonian Library for QuTiP (Quantum Toolbox in Python). Currently, QuTiP users must frequently recreate common quantum system Hamiltonians from scratch, leading to redundant work and inconsistencies. The library will provide ready-to-use implementations of frequently used quantum systems like Jaynes-Cummings, Rabi, Dicke, and various spin-chain models. Key features include a standardised API, JSON serialisation for cross-platform compatibility, time-dependent parameter support, and LaTeX representation capabilities. The deliverables include a core Hamiltonian base class, at least 10 implemented quantum models, comprehensive documentation, tutorials, and full integration with QuTiP's existing functionality. This project will significantly enhance user experience and reduce redundancy in quantum simulations.
This proposal aims to develop a feature-rich programming environment for writing Faust programs in VS Code by providing powerful Language Server Protocol(LSP) features such as code completion, diagnostics checking, definition lookup, etc. and any other features commonly supported by other mature programming language projects. The goal is to enhance and optimize the current Faust programming experience, making Faust development smoother for developers and allowing Faust programming to be more accessible for beginners to the Faust ecosystem.
This is a biparted project in which we first focus on integrating Apache Arrow into OpenMS’s build system and dependency management framework, as simple as that sounds. The goal here is to ensure a solid foundation by creating custom CMake scripts, updating CI pipelines, and ensuring cross-platform compatibility. In the second phase, we will implement a converter that transforms mzML files into the Arrow-compatible Parquet format. This conversion not only preserves the integrity of the original data and also allows for the leveraging of the richer schema evolution and querying capabilities of Parquet. Together, these efforts form the ARROW project, ultimately paving the way to more efficient computational mass spectrometry workflows.
This project extends QEMU FUSE export with support for FUSE-over-io_uring, a modern Linux interface that enables asynchronous, high-performance communication between FUSE daemons and the kernel. Unlike the traditional /dev/fuse path, io_uring reduces system calls, supports batching, and lowers CPU overhead. This project will integrate FUSE-over-io_uring into QEMU as an optional mode, enabling more efficient access to disk image contents through the FUSE export. The work includes implementing queue setup and negotiation with the kernel, supporting multiple inflight FUSE requests, enabling multi I/OThreads, and benchmarking performance using fio. Deliverables include: FUSE-over-io_uring support in QEMU Multi-inflight and multi-IOThread support Performance benchmarks Documentation
This project aims to develop a new deep learning exercise within Robotics-Academy, focusing on end-to-end visual control of autonomous vehicles. The exercise will allow users to upload trained PyTorch/TensorFlow models that process camera input from a simulated car or drone in Gazebo and output control vehicle movement based on the model’s predictions. A web interface will enable model upload, real-time visualization, and performance monitoring. The exercise will include a demo model trained on synthetic data, a Gazebo simulation environment, and integration with ROS2. This exercise will leverage existing infrastructure from previous deep learning-based Robotics-Academy exercises, such as Human Detection and Digit Classifier.
The qaul RPC user authentication layer project aims to implement a secure and scalable authentication system for the qaul network, enabling multiple users per node and ensuring secure communication between libqaul and the user interface (CLI and future Flutter GUI). The primary objective is to develop an authentication and session management system based on public key cryptography, token-based sessions, and encryption through the Noise protocol. To achieve this, the project will focus on several key components: designing a robust authentication system, implementing token-based session management, integrating encryption for secure communication, and building a command-line interface (qauld-ctl) to manage user identities, sessions, and secure communication. Additionally, the project will establish a protobuf communication structure to facilitate these features between the user interface and libqaul.
This project aims to enhance BuffaLogs alerting system by integrating new alerters, standardizing configurations, and introducing advanced features like configurable thresholds, customizable templates, scheduled digests, and rate limiting. It will also implement user-specific alert preferences, email integration, and support for common security platforms. Alongside backend improvements, the project will include detailed documentation, and demo tutorials to improve developer experience and usability.
This proposal aims to update the User Interface and add new features to catch up with the Android version of VLC, enhancing and making the user experience safer and easier. The main feature of this project will be adding to VLC iOS app the Parental Control feature already available on the VLC Android app. This will enable iOS users to restrict access to the app settings and to sensitive actions, such as deleting media files or modifying playlists, unless the user successfully authenticates via a PIN code or biometrics. This is particularly useful in environments where children or unauthorized users might otherwise access media libraries unsupervised. This feature will ensure that VLC for iOS offers the same level of protection and control alongside consistent design guidelines and accessibility currently available in VLC for Android. As part of this effort, some components of the settings interface and media actions will also be reviewed and updated to align with modern iOS UI patterns. Implementing these improvements will strengthen the app’s usability in shared environments and contribute to a safer, more polished experience for all users.
This project aims to implement an in-memory, volatile file system for NVIDIA GPUs using the NVPTX backend in newlib. NVPTX offloading in GCC enables running tests on the GPU, but currently lacks proper file system support. The proposed solution involves two key objectives: (1) developing a lightweight file system driver that operates in the GPU’s VRAM, and (2) redirecting NVPTX system calls in newlib to interface with this in-memory file system. The file system will support basic operations such as file creation and deletion, without requiring recursive directory structures. This work will improve the runtime environment for NVPTX targets and potentially pave the way for future extensions, such as RPC-based host filesystem access or support for AMD GPUs via the AMD GCN backend.
This project aims to develop a hand-gesture computer control system by porting MediaPipe’s Gesture Recognizer to OpenVINO, enhancing performance on Intel hardware. It will have a context-aware system that maps hand movements to keyboard shortcuts, mouse clicks, and other inputs, with the innovation of application-specific mapping where identical gestures trigger different actions based on the active application. Deliverables include converted MediaPipe models (palm detection, landmark detection, gesture embedder, and classifier) in OpenVINO IR format with complete pipeline integration, a real-time gesture control system that achieves at least 20 FPS with smooth cursor tracking, and a user-friendly GUI for customizing gesture-to-input mappings; in addition, performance will be benchmarked across various Intel platforms and the implementation process will be thoroughly documented for future contributors.
This project aims to advance the evaluation framework for Google’s Gemini 2.0 and Gemma 3-27B multimodal models by integrating a diverse set of open-source, domain-specific benchmarks spanning healthcare, robotics, and general-purpose multimodal reasoning. In the healthcare domain, the evaluation will leverage datasets such as VQA-RAD and OmniMedVQA to assess the models' capabilities in interpreting and reasoning over complex clinical imaging and textual data. For the robotics domain, benchmarks like EmbodiedBench and EmbodiedQA will evaluate the models' proficiency in understanding spatial, visual, and language cues for grounded human-robot interaction tasks. Additionally, general multimodal benchmarks such as SME and BenchLMM will test the models’ ability to produce accurate, context-aware, and human-like explanations grounded in visual inputs. To ensure robustness, the project will also incorporate adversarial attack benchmarks across modalities, evaluating how resilient Gemini 2.0 and Gemma 3-27B are against input perturbations—including visual occlusions, textual prompt manipulations, and conflicting cross-modal signals. Alongside task accuracy, we will analyze the relationship between inference time and adversarial attack success, quantifying how model latency and confidence shift under adversarial conditions.
This proposal outlines integrating debugging into the xeus-cpp kernel for Jupyter using LLDB and its Debug Adapter Protocol (lldb-dap). Modeled after xeus-python, it leverages LLDB’s Clang and JIT debugging support to enable breakpoints, variable inspection, and step-through execution. The modular design ensures compatibility with Jupyter’s frontend, enhancing interactive C++ development in notebooks.
The problem I am trying to solve is less monetary benefits received by the data owners. I am creating a decentralized solution where the data owner can upload his/her dataset and get compensated well whenever people buy the dataset. My proposed architecture is secure as well as scalable.
The bot will support real-time spam reporting, rate limiting, and user reputation management. The implementation will leverage Rust for interfacing with the Telegram Bot API, Lua for scripting automation rules, and innovative rule engine design to ensure scalability and responsiveness. The final deliverable includes an advanced moderation UI and comprehensive documentation, benefitting both administrators and the broader open source community by providing an innovative tool for spam mitigation.
The crate cargo-semver-checks provides feedback to user based on what possible breaking changes they may have made, which as per semantic versioning may require that the user accordingly update the semantic version of their library. This ensures that major breaking changes do not occur without notice. However, the feedback from cargo-semver-checks is not always the easiest to understand, in that whatever problem may actually be present is not always obvious. Additionally, cargo-semver-checks sometimes suffers from false-positive, where it detects a breaking change where there is none. This project proposes to remedy many of these issues by leveraging the existing lint data to implement so-called "witness programs", which are designed to demonstrate the breaking change by compiling successfully on a baseline version of the crate being tested, but failing to compile on the new version, due to the error caused by the breaking change. The plan is, following some research at the start, to implement a basic witness system that allows for additional internal queries and generation of a witness program from a template. Following that, implement automated testing of these witness programs to verify they do fail when expected. In the event of an unexpected behaviour, the system should be designed to provide the user with diagnostic information and an easy way to submit an issue to the cargo-semver-checks team. Lastly, these witness program templates then need to be written en masse, utilizing the now created system to provide these witness programs to as many lints as possible. Ideally, by the end of the Google Summer of Code program, 80% of the current lints should have witness program templates. Additionally, it is planned to continuously engage with the Rust community so as to both inform members of the progress of this proposal, but also to encourage accountability over the process of developing this project.