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.
The project will develop a Python-based CLI for CBRAIN using its Python API Client Swagger API, allowing advanced users to manage research data and computational workflows directly via the API. This CLI will support data upload/download, file querying, task creation, execution, and monitoring, enabling remote access to complex research operations without relying on the web interface. The goal is to improve CBRAIN's usability by providing a flexible, programmatic tool for advanced research workflows.
Configurable linter for Concerto (used in the Accord Project) validates syntax and the JSON AST of Concerto models against a curated set of Spectral rules. Rules enforce best practices : such as naming conventions (e.g., camelCase properties, PascalCase declarations) and feature restrictions (e.g., reserved keywords), while remaining fully configurable per project. Lint results surface in the concerto CLI. The tool is designed to be lightweight and performant; it integrates seamlessly with existing concerto tooling and supports extensible rulesets packaged as npm modules. Overall, the project advances Concerto by reducing manual checks, improving model quality, and providing practical rules informed by real user needs, backed by comprehensive testing and easy configuration.
The goal of this proposal is to provide a working prototype of texels buffers which is a new proposed extension in WebGPU API, in Dawn, Chromium's WebGPU Engine). This feature will allow WebGPU developers to bind to a buffer allocated in the GPU as a texture for read/write operations.
This project aims to optimize the calculation of multimodal embeddings (text, image, audio, video) by exposing REST API endpoints in OpenVINO Model Server. It combines the transformers library for data preprocessing with OpenVINO for efficient inference execution. The project will include a Mediapipe graph for preprocessing and inference, along with a sample application for image search using embeddings stored in a vector database. The goal is to enable flexible, efficient comparison of different data types based on semantic meaning.
In the current research ecosystem, datasets and trained machine learning models (e.g., LLMs, CNNs, etc.) are often scattered across various repositories and platforms, making discovery and reuse inefficient. This project proposes the design and development of a unified user interface system within Apache Airavata to consolidate and manage both datasets and models in one accessible platform. The contribution is aligned with the ticket: Come up with UX designs for Airavata data and model catalog. Through modern UI/UX design and seamless integration, this system will allow researchers and developers to find, preview, download, and reuse datasets and AI models effortlessly.
This project tackles the lack of transparency in tree-planting initiatives by developing a decentralized mobile application that leverages blockchain technology for verifiable and tamper-proof tracking. Each planted tree is minted as an NFT (ERC-721), storing critical metadata like geolocation, species, and planter details on-chain. To ensure authenticity, the system incorporates a community-driven verification mechanism where users can validate trees by submitting photo proofs stored on IPFS, earning tokenized rewards (ERC-20) for their participation. A key innovation is the use of geohash-based indexing, which optimizes location queries by dynamically adjusting precision based on map zoom levels, significantly reducing gas costs and improving performance. The app features an interactive map built with Flutter, displaying nearby trees with species-specific icons and enabling users to explore detailed records. To address the issue of tree mortality, the project introduces legacy tokens—ERC-20 rewards distributed to planters who report deceased trees or submit maintenance updates like care photos and videos. Tree NFTs are transferable, with ancestry tracked to maintain historical records. For collective efforts, smart contract-based organizational tools allow groups to manage plantations, add members, and track contributions on-chain. Additionally, each tree is linked to a dynamic QR code stored on IPFS, enabling physical trees to be scanned for instant access to their digital records. By combining blockchain transparency, geospatial efficiency, and community incentives, this project establishes a scalable and trustless framework for global reforestation efforts.
The ros2_control framework uses a plugin-based system to support multiple hardware drivers at the same time. It takes care of resource constraints between different controllers and hardware components, asynchronous operation of controllers, etc. As of now, controller_manager publishes the diagnostics of itself, and for controllers and hardware components about their lifecycle state and operational statistics such as their periodicity and their execution time. However, A current limitation of the framework is that hardware components, e.g. the ros2_control hardware driver plugin for a given robot, doesn't have a good API for reporting the diagnostics of its own hardware, for instance, the state of the CAN Bus, some internal motor control board stats like temperature, error codes etc. This integration would make the ros2_control, provide complete diagnostics within its ecosystem. This project focuses on setting up an API that hardware manufacturers & driver maintainers can use to report things with minimal code changes to their existing setups. This project thus aims to add reporting capabilities to the hardware components with minimal changes. It will also aim to unify the three existing hardware interfaces into one as they currently contain a lot of similar code. Furthermore, to enhance the contribution, there will also be focus on adding contributions to exisiting widely used Hardware Interfaces with the new API so that the work is adopted with ease, and the community has better references to work off of.
This GSoC project focuses on strengthening SymPy's assumptions system through a two-fold approach. The first component targets relational reasoning by addressing key inference gaps, without needing explicit real assumptions. Additionally, it involves integrating an incremental SAT solver to significantly improve the performance of ask and satask by enabling clause reuse across queries. The second part of the project introduces support for quantified logical reasoning. By implementing universal and existential quantifiers (Q.forall, Q.exists), SymPy users will be able to express and evaluate rich, domain-spanning mathematical statements. This will be realized using a hybrid strategy, combining Z3-style pattern-based instantiation with SymPy's symbolic, declarative assumptions system. Together, these enhancements aim to make SymPy's logic engine more expressive, efficient, and mathematically powerful.
AprilTags, FAST, and ORB are fundamental feature detectors in computer vision and robotics. AprilTags provide robust fiducial markers widely used for calibration, pose estimation, and robot navigation. FAST enables efficient corner detection, which serves as the basis of lightweight real-time applications. ORB combines FAST keypoints with binary descriptors for robust feature extraction and matching in in unstructured environments, making it suitable for tasks such as SLAM and visual localization. This project implements these detectors in Rust, emphasizing efficiency, modularity, and ease of use. All modules are integrated into the kornia-rs ecosystem, expanding its toolkit for robotics, augmented reality, and camera calibration.
As we plan to take the PSLab project to the next level, developing multiplatform support for the app and enhancing its communication capabilities are key to making PSLab more accessible and effective for students, educators, and science enthusiasts across diverse environments. Currently, the Pocket Science Lab (PSLab) mobile application is available only for Android, limiting its usability in institutions where iOS, desktop, or web platforms are widely used. This project aims to rebuild the existing Android app using Flutter, enabling support for Android, iOS, desktop (Windows, macOS, Linux), and web, all from a single codebase. Flutter’s flexibility and performance make it an ideal choice for this cross-platform transformation, ensuring a smooth user experience across all device types and screen sizes. Another crucial part of this project is enhancing the hardware communication layer to accommodate platform-specific constraints—particularly Apple’s restrictions on USB communication. To address this, the project will implement Wi-Fi-based connectivity using the ESP01 chip, allowing seamless data transfer between the app and the PSLab hardware across all platforms. This ensures that iOS and web users are no longer at a disadvantage and can fully utilize the PSLab instruments. By the end of the project, the app will offer a robust, real-time interface for core instruments like the Oscilloscope, Logic Analyzer, Multimeter, and Robot Controls, complete with interactive visualizations.
I am going to write the code for the ADE9113 IIO Driver and the related device tree documentation. I will also provide a comprehensive tutorial detailing the development process and the steps to create the driver, along with a functional demo showcasing the driver working with the hardware. In the end, this work will be submitted for inclusion in the upstream Linux Kernel.
Alaskan coastlines are rapidly evolving due to the direct impacts of climate change. Rising sea levels, melting sea ice, and shifting environmental conditions make accurate modeling of coastal changes a pressing need. Current approaches often miss key environmental variables like tidal shifts, temperature variation, and wave energy. Moreover, manual coastline digitization remains time-consuming and inefficient, limiting scalability. The aim of the project is to develop and deliver a highly accurate, automated model that can extract vectorized coastlines directly from PlanetLabs satellite imagery. This will build upon the existing pipeline and model by re-training the water detection (NDWI-based) and segmentation methods to perform well on PlanetLabs’ imagery. Further aims include: Ensuring the extraction is robust in challenging conditions such as water shadows, buildings, artifacts, and especially steep, cliff-like coastal areas. Integrating additional data sources if needed, such as SWIR data the project will also explore the use of auxiliary data sources (Landsat & sentinel) and elevation data for addition of topographic information, to improve accuracy. Ultimately producing a finished model that can process large amounts of imagery and accurately predict coastline changes over time, which is essential for improving coastal erosion forecasts in Alaska considering the effects of climate change.
Open Data PVNet aims to democratize solar energy forecasting by extending the PVNet framework to work entirely with publicly available weather datasets like GFS, DWD ICON, and ERA5. Current solar forecasting models often rely on proprietary data, creating barriers for researchers and developers in low-resource settings. This project will build a training pipeline based on open NWP data, enhance data preprocessing tools, and benchmark PVNet’s performance using these sources. Key deliverables include zarr-formatted datasets, an open-source training pipeline, performance evaluation scripts, and comprehensive documentation. The end goal is to make high-quality solar forecasting more accessible, scalable, and globally impactful.
This project aims to enhance RUXAILAB, an open-source platform for usability evaluation, by integrating three key components: eye tracking, sentiment analysis, and pre/post form tasks. These additions will support real-time, data-rich user testing and improve the understanding of user behavior and emotional responses. We will embed affordable eye tracking to visualize attention (e.g., heatmaps, gaze paths), implement multimodal sentiment analysis using facial expression recognition and NLP, and enable customizable pre/post-test forms to evaluate usability (e.g., SUS, NASA-TLX) and cognitive load. Built with a user-centered, modular, and API-first approach, the project will also define evaluation protocols, publish open datasets, and validate the system with real users. The outcome will be a comprehensive, extensible, and community-driven tool for empirical UX research, bridging qualitative and quantitative insights.
This project aims to improve the way Scautable handles CSV files by making structured data parsing in Scala more robust, flexible, and user-friendly — especially for data exploration and quick scripting tasks. Key problems being addressed include poor handling of row/column mismatches, limited support for malformed or missing headers and lack of custom delimiter options. Inspired by the usability of Pandas, this proposal introduces enhancements such as configurable error-handling modes (e.g., skip or autofill bad lines), support for automatic or custom headers, smarter handling of duplicate or malformed columns, and flexible delimiter parsing. For large files, methods to access specific columns will be distributed across implicit classes to avoid JVM method count limitations, improving scalability. Additionally, clear error messages and diagnostics will guide users through common issues and edge cases. By addressing these aspects, the project will significantly improve Scautable’s reliability and make it a more powerful tool for developers working with structured data in Scala.
SymPy currently lacks an efficient backend for dense and sparse multivariate polynomials over ℤ and ℚ, leading to performance bottlenecks in many core functions such as solve, linsolve, simplify, cancel, and polynomial GCD computations. This project aims to address this by integrating FLINT’s highly optimized multivariate polynomial arithmetic into SymPy via python-flint. To achieve this, we will implement: FLINT-backed Sparse Polynomial Support – FlintPolyRing (FLINT-backed equivalent of PolyRing), FlintPolyElement (FLINT-backed equivalent of PolyElement), comprehensive tests and documentation. FLINT-backed Dense Polynomial Support – DMP_Flint (FLINT-backed dense multivariate polynomial class), comprehensive tests and documentation. Performance Analysis and Optimization – Benchmarking against SymPy’s existing implementations, optimizing operations. This is a high-priority task in SymPy's development roadmap, and achieving this can make SymPy reach "state-of-the-art" levels of speed and performance. Since multivariate polynomial operations are involved across various modules in SymPy, this project significantly strengthens the library.
GeNN is a C++ library used for simulating Spiking Neural Networks through GPU-based code generation (CUDA/HIP). Currently, its accessibility is limited to users with a dedicated GPU system. This project aims to address this limitation by adding an ISPC (Intel’s Implicit SPMD Program Compiler) code generation backend model to the GeNN library to enable efficient SNN simulations on SIMD (Single Instruction, Multiple Data) capable CPUs . My project will expand GeNN’s accessibility to those users who do not have a dedicated GPU system while delivering high performance through CPU SIMD parallelism. I will work on backend architecture design, SIMD optimization, build system integration, and benchmarking against existing GPU implementations .
PostgreSQL introduced Server API and ABI Stability Guidance to help extension authors understand compatibility expectations. The policy ensures ABI stability between minor releases (e.g., 17.0 to 17.1) but allows changes in major versions. Currently, committers rely on manual reviews to enforce this, which occasionally leads to unintended ABI changes. A recent example occurred in PostgreSQL 17.1, where an ABI-breaking change was shipped and later reversed in 17.2. This incident highlights the need for an automated process to catch such issues before release. To enforce ABI stability, this project will monitor PostgreSQL’s repository across STABLE branches, detecting any ABI breakage early. Since ABI changes depend on system architecture, OS, and compiler, the tool will be developed as an extension to PostgreSQL Build Farm, leveraging its infrastructure to handle diverse configurations. Git receive hooks are unsuitable as PostgreSQL does not allow them due to repository performance concerns. As the frequency of commits on the PostgreSQL stable branches is very low, build farm’s cron based clients (animals) can simply compare the latest commit build(which it already does) with the latest release tag or the most recent minor release to get the ABI breakage, if any. The Libabigail suite (abidw, abidiff) will be used for ABI compliance checks, currently supporting GCC and Clang, with future expansion planned for other compilers. The system will generate ABI compliance reports on every run and will send to the build farm server and notify the community about breaking changes. This project will include the development of a Build Farm Client Perl Module that generates ABI compliance reports and report any ABI Breaks to the community. This project will strengthen PostgreSQL’s ABI stability process, preventing unintended breakages and ensuring smoother minor releases.
The main goal of this project is to develop the R interface for JuliaBUGS, enabling a broader range of users already familiar with these languages to leverage the features of JuliaBUGS. This integration will not only facilitate the use of JuliaBUGS’ concise formulation alongside modern methods such as Hamiltonian Monte Carlo (HMC) and Automatic Differentiation (AD) but will also attract new users, helping to expand, consolidate, and strengthen the Julia community. The project will be under the umbrella project Turing.jl, and will have a duration of 175 hours.
LLVM generates valuable information through remarks, profiling, and runtime annotations that becomes difficult to navigate as projects grow. This project aims to create a unified infrastructure to collect, organize, and visualize compilation data from the LLVM offloading toolchain. The tool will function as a compiler wrapper that captures JSON-formatted information and presents it through an interactive web interface. By providing accessible visualization of optimization decisions, profiling data, and compilation metrics, the tool will help developers make data-driven decisions rather than relying on trial and error.
HarmonyHub is an open-source, modular web application designed to revolutionize music education by integrating modern technologies and pedagogical principles. Built using Ionic and Angular, it provides educators with reusable components and services to create adaptive and personalized learning experiences. Initially focused on trumpet players, the platform is now being expanded to support other variable-pitch instruments like wind (e.g., Flute, Clarinet) and bowed string instruments (e.g., Violin, Viola). By blending traditional music instruction with cutting-edge digital tools, HarmonyHub enhances practice strategies, making learning more engaging and effective. Mastering wind and bowed string instruments is challenging, requiring structured practice and targeted support. HarmonyHub addresses this need by bridging the gap between conventional teaching methods and modern technological advancements, ensuring students receive interactive and personalized guidance. In an era where digital transformation is redefining education, integrating Information and Communication Technology (ICT) into music learning enhances skill development, creativity, and motivation. By refining its interface and expanding its instrument coverage, HarmonyHub paves the way for a more inclusive, accessible, and innovative approach to music education.
What good is a revolutionary learning platform if teachers still have to juggle Zoom, docs, and third-party whiteboards just to conduct a class? After working on Alpha One Labs for long, I’ve realised that with all the current components like courses, videos, blogs, quizzes…. The one component that is missing is indeed the most important one - A Virtual Classroom. (and what if this virtual classroom becomes a 2D user controlled experience?) I am going to implement a 2D user controlled classroom experience. A game like interface where the user can go around the classroom, take seats with their friends, interact with multiple areas of the class, like the whiteboard, assignments table, breakout rooms, working on assignments alone or as teams, and a lot more. Along with this im building an AI assistant available throughout the website. This AI assistant will be your guide for any feature at Alpha One. The need of this has increased with the number of features at Alpha One. Any query regarding the working of the website will be resolved instantly. at the end of the project we will have: A 2D user-controlled classroom experience with integration of multiple existing features at Alpha One and new features, which will also act as independent features for the platform. An AI assistant available on all pages of Alpha One, resolving any query regarding the website instantly.
The VedicDateTime R package is a specialized toolkit designed to handle date-time computations in the context of the Vedic calendar system. Initially developed through GSoC 2022, the package has proven valuable for researchers, historians, and practitioners interested in traditional Indian timekeeping. However, as user adoption has grown, so has the demand for improved accuracy, better integration with modern R workflows, and expanded functionalities.
This project focuses on optimizing and deploying EduAid, an AI-powered tool that generates interactive quizzes from educational content. Key deliverables include: - Adaptive Difficulty Control: NLP-driven question generation targeting overlooked concepts using TF-IDF scoring and synonym replacement. - Multilingual Integration: Leveraging the T5 model to enable question translation into German, French, and Romanian. - Scalable Infrastructure: Deployment via Electron.js, Celery-Redis task queues for scaling by the factor of 10x. - Performance Enhancements: Model quantization (25% size reduction), ONNX runtime acceleration (65% latency improvement), and service workers for background processing. - Unified UI/UX: Revamped frontend with reusable components and IndexedDB migration for efficient data handling.