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.
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.
This proposal aims to address the challenge of robust and accurate GPS-denied navigation for UAVs equipped with lightweight 3D cameras. The core problem is that while camera-based visual odometry can struggle in certain environments and LiDAR systems are often too heavy and expensive for all UAVs, there is not a reliable way for lightweight UAVs to leverage the high-accuracy 3D maps generated by more capable mapping systems. The proposed solution is to develop a framework that allows UAVs with 3D cameras to utilize pre-generated, centimeter-level 3D maps for navigation. This will involve a C++ based ROS2 package designed to run on a companion computer. This package will: 1. Process the pre-generated maps. 2. Implement point‑cloud matching algorithms (such as ICP and NDT) to align live camera scans with the existing map and compute a 6‑DOF pose. 3. Fuse the estimated pose with IMU data using an Extended Kalman Filter (EKF) to provide smooth, high‑rate odometry and improve Z‑axis estimation. 4. Incorporate a state machine to manage odometry data, perform sanity checks (e.g. data‑rate drops, connection loss, time desync, corrupted messages), and transmit the validated pose to the UAV’s firmware via MAVLink over serial. The key deliverables of this project include: 1. A fully functional prototype in simulation capable of generating maps and producing 6‑DOF estimates with the 3D camera. 2. Algorithm design, implementation, and sensor fusion. 3. System integration, validation, and documentation. 4. A complete hardware setup.
This proposal addresses the current issues with Rocket.Chat’s API documentation, which is fragmented and manually maintained, leading to inconsistent validations and outdated information. The plan is to convert all API endpoints to use the OpenAPI 3.1 standard, integrate AJV-based validation for both requests and responses, and merge all documentation into a single, interactive Swagger UI portal. The key deliverables include: A complete, OpenAPI 3.1 compliant API specification covering all endpoints. AJV-based validation integrated across the API to reduce runtime errors. A unified documentation portal accessible via /api-docs with interactive Swagger UI. This approach aims to improve developer experience, ensure type safety, and maintain backward compatibility while providing a robust, automated solution for API documentation and validation.
Network Device Interface (NDI) is a software specification that enables high-definition video transmission over a computer network with low latency and high quality. This project aims to enhance an open-source implementation of the NDI protocol, libNDI, by adding support for sending NDI streams, expanding protocol support for NDI-HX2 and a UDP-based NDI variant, improving performance, stability, and security. Then integrate libNDI into VLC.
The project aims to complete the development of the Tauri Desktop Application. This project will finally mark the completion of the Vue-simulator and replace the legacy simulator with the Vue-simulator. This project has been divided into 7 parts - 1. Fixing the current bugs in the simulator and Desktop App - Fix the bugs, refactor the user Authentication for the Desktop Application, fix the broken Verilog module and Test bench enhancements. 2. Type script integration and Vue frontend updates - Ts integration, replacing Options API with Composition API, replacing JQuery with Vue's reactivity and increasing the use of Vue lifecycle hooks. 3. Testing for Web and Desktop simulator - Fix the current test failures, Mock APIs for desktop application testing, writing additional tests for Tauri app for the Verilog, Testbench fixes and the additional features added to Tauri App. 4. Integration of Vue simulator with the primary codebase - Replace the legacy simulator with the vue-simulator for development and production. 5. Versioning of App and Release for the Desktop Application and Update Mechanism for Tauri App - Deploying a seamless release pipeline for versioned releases with the artifacts mentioned, optimizing those built artifacts, and implementing a reliable update mechanism to deliver the future improvements seamlessly. 6. Implementing Verion switch (backend). 7. Documentation for the Vue-simulator and the Desktop Application.
This proposal is based on the LLVM project for GSoC 2025 with the same title, from Tue Ly and Nicolas Celik. Discourse: https://discourse.llvm.org/t/libc-gsoc-2025-bfloat16-in-llvm-libc/84469. Bfloat16 (aka "Brain Floating Point") is a recently developed floating point format by Google. Similar to IEEE 754 binary16, it is applicable in machine learning and AI providing significant improvements in training and performance. It is officially standardized as std::bfloat_t in the latest C++23 standard. The goal of this project is to implement support for this type in LLVM libc. Deliverables: - Implement the type in a compiler and architecture agnostic way. - Implement generic basic math operations that work on all supported architectures. - Implement specialized hardware specific optimizations and compiler built-ins for higher performance. - Investigate higher math functions if time permits.
Smart home environments are increasingly popular, integrating a wide range of IoT devices to enhance user experience. However, the complexity of managing these devices limits the realization of their full potential. SmAuto, originally developed by the ISSEL research team at AUTH, is a Domain Specific Language (DSL) that simplifies the creation of complex automation scenarios for smart environments through a textual and web-based low-code interface. Currently, SmAuto lacks features such as integration with external REST data sources, time delays, semantic annotations, and direct access to HomeAssistant (HA) entities, restricting its utility in advanced smart home setups. This project aims to enhance SmAuto by: Extending the DSL to support the REST protocol for accessing external data sources. Introducing auxiliary concepts like Delay, Switches, and Compute nodes to enrich automation workflows. Integrating SmAuto into HomeAssistant as an open-source addon, enabling users to design and deploy automations graphically using SmAuto’s low-code environment and HA’s existing entities.
Implementation of primarily two features: 1. A multi-device bookmarks sync feature on Android, similar to the iCloud sync available on the iOS app. This will allow users to securely maintain the same set of bookmarks across multiple devices without the need of any manual intervention. 2. A simpler one-way bookmarks backup feature, similar to the approach of WhatsApp to Google Drive/iCloud backups. This will allow users to securely store their bookmarks and restore them when needed. The implementation will include pure client side encryption. It will be designed to allow for easy addition of support for any cloud storage provider. The initial implementation will include support for Google Drive and Nextcloud. The UX (authentication flow and configuration) will be kept simple and accessible.
HALO (Hierarchical Abstraction for Longform Optimization) is an MIT-licensed Python package for efficient large-scale video content analysis, installable via pip install halo-video. The system implements a hierarchical processing architecture that reduces computational complexity to O(n log n) using dynamic content-based segmentation. Key components include: a multi-modal fusion pipeline integrating visual (768-dimensional) and transcript (1024-dimensional) embeddings; a three-tier caching system utilizing in-memory hash tables, disk-based serialization, and compressed vector storage; and an optimization layer for API request batching. The architecture maintains content coherence through a sliding context window with 30% chunk overlap. Performance metrics show 93% reduced processing time, 85% lower computational costs, and 98% fewer API calls compared to baseline approaches. HALO supports cross-platform operation (Linux, macOS, Windows), implements error handling with exponential backoff, and provides standardized interfaces for integration with existing ML pipelines. The package processes video content with bounded memory requirements regardless of input length.
This project is intended to improve the interoperability between LS‑DYNA and BRL‑CAD by enhancing the existing k‑g converter and by implementing a new g‑k converter. The primary goal is to facilitate a seamless data exchange between LS‑DYNA keyword files and BRL‑CAD geometry databases, ultimately streamlining workflows for users who need to transition between advanced simulation and detailed geometric modeling.
This project proposes building a new, modern web UI for Mifos X using React, Tailwind CSS, TypeScript, and ShadCN components. The new Mifos X will be integrated with the Apache Fineract backend using the official TypeScript API client to ensure seamless data flow and backend connectivity. Deliverables include a fully responsive, modular UI for Mifos X modules and complete integration with Fineract APIs. The new Mifos X will enhance user experience and provide a solid foundation for future improvements.
The Eclipse OpenJ9 project is a high-performance, scalable Java Virtual Machine (JVM) designed for cloud and enterprise applications, where debugging test failures can be time-consuming, especially in identifying the exact commit responsible for the test failure. CommitHunter aims to automate this process by first implementing a rule-based system using string matching and binary search to efficiently detect faulty commits. It will then evolve into an AI-driven model, leveraging machine learning trained on historical build data, commit logs, and failure reports to classify commits as "Likely Problematic" or "Safe". By integrating with GitHub APIs, CommitHunter will automate issue tracking, significantly reducing manual debugging efforts, improving test failure triage, enhancing overall development efficiency and resultant bot will comment accordingly on the git issue while offering a scalable solution for broader adoption.
Amharic Wikipedia lacks structured knowledge representation, which limits its integration into global knowledge graphs like DBpedia. This gap hinders the accessibility, discoverability, and interoperability of Amharic content in multilingual semantic web applications. This project proposes to enhance the Amharic chapter of DBpedia by extracting structured data from Amharic Wikipedia. It involves extending the DBpedia Extraction Framework to support Amharic, creating new mappings for infobox templates, and extracting rich semantic data such as citations, disambiguations, and anchor texts. The output will be published as RDF triples and made accessible via a user-friendly web interface, following FAIR (Findable, Accessible, Interoperable, Reusable) data principles. Deliverables • An Amharic-compatible extension to the DBpedia Extraction Framework. • New infobox mapping templates for Amharic Wikipedia. • An automated extraction pipeline with support for citations, disambiguation, topical concepts, and personal data. • A structured knowledge graph (RDF triples) linked with English DBpedia and Wikidata. • A lightweight web interface with SPARQL querying and multilingual support. • Comprehensive documentation covering setup, usage, and FAIR-compliant publishing.