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 aims to transform the CircuitVerse mobile application into a fully functional, stable, and production-ready platform that matches the capabilities of its web counterpart. Currently, gaps in core features, inconsistent user experience, and technical instability limit the app’s effectiveness as a learning tool. By addressing these challenges, the project focuses on implementing missing web features, stabilizing authentication, and restoring key modules such as the interactive book to ensure a seamless and engaging learning experience on mobile devices. In addition to feature parity, the project emphasizes improving performance, fixing critical bugs, and enhancing UI consistency and accessibility. A scalable and maintainable architecture will be established to support long-term growth and easier development. Special attention will also be given to localization and multilingual support, making the platform more inclusive and accessible to a global audience. Overall, this initiative is important for CircuitVerse as it enables broader reach, improves usability for mobile users, and ensures that students worldwide can reliably access interactive digital circuit learning resources anytime, anywhere.
The Environmental NeTworked Sensor (ENTS) platform is an open-source web portal designed for collecting, visualizing, and analyzing data from large-scale environmental sensor networks. It enables researchers and citizen scientists to monitor sensors measuring soil moisture, temperature, current, and voltage in outdoor settings, supporting critical environmental research. This project aims to enhance the ENTS platform through two key initiatives. The first focuses on system stabilization to address existing visualization and reliability issues, ensuring that data presentation is accurate and consistent. The second initiative will implement a comprehensive Logger Registration System, allowing users to easily add, configure, and monitor their logging devices, with potential integration to The Things Network for LoRaWAN connectivity. By the end of this project, ENTS will feature improved chart synchronization, reliable data point selection, robust error handling, and an intuitive interface for registering and managing logging devices. These enhancements will transform ENTS into a more stable, user-friendly platform that better supports researchers in collecting and analyzing environmental data at scale.
Multi-output Gaussian processes (MOGPs), a type of Bayesian nonparametric models, have recently gained strong attention from researchers, and become an active research topic in machine learning’s multi-task learning. The advantage of multi-output GPs is its capacity to simultaneously learn and infer many outputs which have the same source of uncertainty from inputs. This provides a useful and practical approach for various applications in different fields. The creation of new sampling methods and the advance in computing power have paved the way for the development of Bayesian models. Different software frameworks have been built to facilitate this probabilistic programming approach. Among those, PyMC is one of the most popular frameworks with a large and strong community. PyMC provides friendly interfaces that allow users in academics and industries to perform both parametric and nonparametric Bayesian data analysis. For Bayesian nonparametric models, the Gaussian process module in PyMC supports various mean and kernel classes. However, the current GP implementations in PyMC are limited to single output. This project aims to add support for multi-output GPs in PyMC. This feature would significantly extend the capabilities of this important module and benefit the PyMC community.
Gemma Facet is a comprehensive platform that provides an end-to-end solution for fine-tuning Gemma language models through a microservices architecture. The platform implements four core services: dataset preprocessing with support for local and Hugging Face datasets, automated training jobs using Unsloth and Transformers libraries, model inference capabilities, and flexible export functionality supporting multiple formats (adapters, merged models, and GGUF). The backend leverages Google Cloud Run services for scalable compute, Firestore for database operations, and Google Cloud Storage for artifact management. The frontend is built with Next.js, Tailwind CSS, and Shadcn UI, providing an intuitive dashboard interface. Infrastructure is managed through Terraform with containerized services using Docker. The system handles complex workflows including dataset splitting configurations, asynchronous training job management, and multi-format model export pipelines. Key technical implementations include Cloud Run Job integration for resource-intensive operations, comprehensive API design with full documentation, and optimized data processing pipelines for efficient model fine-tuning workflows.
We usually need visualization, in fact, to enhance the interpretability of data or results, and facilitate the understanding of developers and users. In machine learning, 3D or 4D representation provides more depth information than the 2D representation, many of the tasks may be much better understood if we provide a 3D or 4D. But OpenVINO has no native real-time 3D visualization engine or library. This can be very troublesome for users who use display 3D images. So our goal is working natural 3D support for Jupyter Notebooks running OpenVINO (AI inference). There are a few solutions in Jupyter 3D graphic display, though: 1. Requires complex setup, build or is not friendly to the average user (without graphics programming experience) 2. Not integration with OpenVINO(Need process different data and different inference results available from OpenVINO, the user only needs a simple interface to set this up) The project idea aims at fill in the gaps mentioned above: 1. Provides a clean interface to set up the display of these graphics without the need for a graphical programming background(beginner-friendly) 2. 3D support for Jupyter Notebooks running OpenVINO(Be able to transform and process the output data of OpenVino)
This project aims to fine-tune Vision-Language Models (VLMs) for domain-specific tasks like object detection and hierarchical classification, focusing on real-world applications in fields such as medical diagnostics and biodiversity monitoring. Although VLMs like BLIP-2 and TinyCLIP show strong general-purpose performance, their effectiveness diminishes in specialized domains due to domain shifts, hierarchical label structures, and hardware constraints. To address this, we will implement efficient fine-tuning strategies—including LoRA, QLoRA, and adapter tuning—within the OpenVINO Training Extensions (OTX), enabling scalable training on consumer-grade GPUs. We’ll enhance these models with support for structured prediction and deploy them using OpenVINO’s quantization and optimization toolchain, ensuring fast, lightweight inference across devices. Beyond technical contributions, the project delivers practical tools and open-source pipelines that bring advanced multimodal AI to resource-limited environments. By supporting transparent, efficient deployment of VLMs in impactful domains, this work bridges cutting-edge research with high-value, real-world use cases.
The project focuses on integration of FUSE-T kextless module for CVMFS on macOS. This initiative is motivated by the computational demands of particle physics, especially those associated with the Large Hadron Collider, which necessitates efficient and reliable software deployment across a massive, globally distributed computing grid. CVMFS (CernVM File System) plays a pivotal role in this process, serving as an optimized, POSIX-compliant read-only file system designed for user space via FUSE modules, thus facilitating software distribution. I propose replacing the current MacFUSE module as kernel extensions facing deprecation by Apple, with FUSE-T, a user-space module claimed to be a drop-in replacement. This transition addresses the issues with kernel extensions (kexts) and aligns with Apple's shift towards prohibition of support for them. Such approach potentially seems to be the most user-friendly in terms of security. The project involves various stages, including adapting CVMFS to use FUSE-T, benchmarking file operations, and investigating libfuse's new features like FUSE_CAP_SPLICE_MOVE. Deliverables include the successful integration of FUSE-T into CVMFS, benchmark reports on file operations, and an evaluation of libfuse updates.
<p>DeepChem has enabled powerful and practical applications for machine learning in many disciplines of the natural sciences. While its name recognizes its historical origins as a tool for analyzing chemical molecules, its reach has more recently broadened to encompass neighboring fields such as materials science and biology. The goal of this proposal is to expand DeepChem’s burgeoning infrastructure to better support protein modeling.</p> <p>This proposal will add a simple codon featurizer to DeepChem, which will be the first DeepChem featurizer capable of directly processing RNAs and protein sequences.</p> <p>It will also add new model classes to DeepChem’s models directory. These classes will act as wrappers for models in Facebook’s Evolutionary Scale Modeling (ESM) repository. They will enable DeepChem users to use ESM’s Multiple Sequence Alignment transformer and Protein BERT models to perform efficient, scalable transformer learning.</p> <p>Also including carefully planned additions to DeepChem’s documentation, unit tests, tutorials, and the MoleculeNet benchmarking suite, this proposal will empower DeepChem users to perform large scale protein modeling while staying within our ecosystem.</p>
The ZOO-Project is an SDI manager which gives the users the capability of building their own map and web applications using Map server as the Open Geospatial Consortium (OGC) services engine. It is an open-source implementation of the OGC's Web Processing Service (WPS) standard. WPS Interface Standard provides rules for standardizing how inputs and outputs (requests and responses) for geospatial processing services (eg. polygon overlay). WPS also standardizes how a client can request the execution of a process, and how the output from the process is handled. The existing ZOO-Kernel supports C, C++, and JavaScript implementations. With this project, the objective is to have the ZOO-Kernel passing all the tests for WPS 1.0.0 and 2.0.0 OGC ETS. During the GSoC the main focus is on making the WPS 2.0.0 test suite working properly. The async tests are still wrong currently and should be fixed, this will be done during the GSoC. The next and final step will be to get the WPS 1.0.0 test suite working and comprehensive enough to get the Test Suite or the ZOO-Project fixed. Moving from OGC API - Processes - Part 1: Core to WPS 2.0.0. can also be added as second step for the project.
The proposal aims to enhance Dubbo-python to meet the evolving needs of the AI sector by addressing compatibility issues, architectural limitations, and functionality gaps. Currently, Dubbo-python faces challenges due to its reliance on Python 2, deprecated libraries, and incomplete RPC communication capabilities, hindering its adoption within mainstream AI frameworks. To tackle these issues, the plan includes: 1. Upgrading Dubbo-python to support Python 3 and modernizing its architecture following the Microkernel + Plugin design principle. 2. Implementing complete RPC communication functionality, including server-side service exposure and client-side service invocation, with support for the new Triple protocol. 3. Developing service governance capabilities such as service discovery, registration, and load balancing, including the design of a GPU metric-based load balancing algorithm to address GPU workload imbalances in AI frameworks. 4. Writing comprehensive test codes to ensure the reliability of each functionality and providing detailed documentation to facilitate easier adoption and contribution to Dubbo-python. By accomplishing these objectives, the aim is to transform Dubbo-python into a robust, high-performance RPC framework compatible with mainstream AI frameworks, thus empowering developers to build scalable and efficient AI systems.
This proposal targets the HSF 2026 idea Clad as a first class gradient engine in libtorch, a 350-hour project intended to make compiler-generated gradients available from LibTorch and, eventually, easier to reuse from the ROOT ecosystem. My goal is to build a practical and well-scoped integration path that allows a LibTorch C++ training loop to call Clad-generated derivative code for a small but meaningful subset of workloads. The primary implementation path is to wrap Clad-generated backward logic inside torch::autograd::Function, because the PyTorch C++ frontend explicitly supports custom autograd functions and presents them as the standard way to integrate optimized forward and backward code in extensions. If time permits and the API proves cleaner, I will also evaluate a custom-operator path based on the PyTorch C++ extension mechanisms. This proposal is intentionally scoped as a proof of concept, not as a general replacement for LibTorch autograd. A realistic first milestone is to differentiate selected training kernels or small model components written in C++, expose them to LibTorch, and measure where compiler-generated derivatives are correct, maintainable, and competitive. This produces a concrete result for mentors and also establishes a clear baseline for future work on broader operator coverage, deeper ROOT integration, or GPU support.
Deep learning is now used to solve many different CV problems. A typical approach is to train a separate network for each specific task. However, there is a need for models that are closer to the human brain and can solve multiple tasks. Multi-task learning (MTL) is a branch of machine learning, in which multiple tasks learn simultaneously through a shared model. It has the following advantages: improving data efficiency, reducing overfitting through shared representation, and using auxiliary information to learn quickly. The project has four objectives: 1. One or more multi-task CV models trained (or borrowed, if the license is appropriate), and submitted to OpenCV model zoo. Specifically, at least MCN or networks with similar functions should be successfully transplanted or improved for OpenCV, and the accuracy and less computation should be provided, which is not lower than that of the existing single OpenCV model. 2. quantize the model on the condition that the accuracy does not decrease too much. At least try to quantize the model and make a trade-off between performance and effectiveness at the end. 3. Necessary patches, if any, for OpenCV DNN to support the provided multi-task models. Ideally, there should be an API introduced to optionally disable some parts of the multi-task CV model and save time by not computing unnecessary parts/heads of the model. 4. Using at least one example will demonstrate how to use this multi-task model.
Currently, the StablePay ecosystem only processes payments for Djed Osiris. As the Djed protocol expands to include new variants like Djed Shu, Tefnut (ETH-backed), and Isis (ERC-20-backed), the payment infrastructure must evolve. The goal of this project is to refactor the StablePay widget, merchant dashboard, and demo sites to seamlessly support any Djed variant without hardcoded assumptions. Additionally, this project will introduce support for the Gluon protocol, which entails deriving the essential mathematical formulas required for pre-calculating neutrons and protons. To achieve this, I will develop protocol adapters that interact with abstracted Djed interfaces, allowing different stablecoins to be plugged in via configuration. I will upgrade the merchant dashboard to enable multi-stablecoin management, allowing merchants to set preferred price feeds and monitor per-stablecoin revenue. Additionally, I will build deployment tooling to auto-generate config bundles from on-chain metadata and improve the end-user UX to handle coin selection, oracle status, and fallback logic gracefully. Ultimately, this project will transform StablePay into a highly scalable, agnostic payment gateway. Deliverables will be secured with comprehensive integration testing (using Foundry/Hardhat) and frontend end-to-end testing, alongside detailed documentation for merchants to easily onboard new networks and protocol versions.
This project addresses the growing challenge of managing Software Bill of Materials (SBOM) data at scale. While SBOMs in the SPDX format are essential for software supply chain security, current file-based approaches (e.g., JSON or RDF/XML) are not well-suited for complex querying, or large-scale analysis. To overcome these limitations, this project proposes a set of tools that leverage RDF triplestores for storing and managing SBOM data. SPDX documents will be parsed into structured Python objects, transformed into RDF triples, and stored using a unified triplestore abstraction layer. This approach enables powerful querying through SPARQL while remaining database-agnostic, supporting multiple backends such as Apache Jena, GraphDB, Blazegraph, AllegroGraph, and Oxigraph. The project will deliver a complete pipeline for SBOM ingestion, storage, and reconstruction. Key deliverables include: (1) a CLI-based ingestion tool for importing SPDX documents into RDF databases, (2) an export tool for reconstructing valid SPDX documents from queried data, (3) management utilities for CRUD operations on SBOM data, (4) a comprehensive test suite to ensure correctness across multiple backends, and (5) detailed documentation for both users and developers. This approach transforms SBOM data from static documents into a structured, queryable knowledge graph, enabling more efficient retrieval and analysis across different systems and backends.
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.
Wireless communication and in particular WiFi networks are becoming more and more important. Research already focuses on improving reliability, performance of such networks and also efficiency of the underlying hardware. One promising candidate for improvements is TX-Power Control (TPC). Adjusting the transmit power per packet basically promises improvements in overall throughput in wireless networks and/or the efficiency by improved resource allocation in wireless networks. Dated back to 2007, Atheros IEEE 802.11a/b/g/n chipsets driven by ath5k and ath9k Linux drivers did first and Mediatek joined recently with hardware support for tx-power control. Those also allow access to set the tx-power per packet, but yet do not provide a driver interface for this. Unfortunately, also the mac80211 subsystem, which is responsible for WiFi communication in the Linux kernel, does not provide an appropriate API to support TPC and per-packet annotation of tx-power. The goal of this project is to implement the missing three-tier software parts: (1) mac80211 structs to annotate tx-power levels per packet, (2) mac80211 structs to account tx-power status information once transmitted and (3) a transmit power control (TPC) API for TPC algorithms. This is achieved by developing and implementing the required structs in the mac80211 subsystem, modifying Linux WiFi drivers to make use of this API, and testing and validating the implementation in several experiments.
For simulating a system that contains many variables and/or equations, traditionally computational engineers tend to focus on utilizing an appropriate method with realistic time and space complexity. The technique of model order reduction (MOR), however, aims at approximating the original model with reduced number of variables and/or equations and still keeping sufficient accuracy. MOR is especially useful in various industries, for example thermal-fluids engineering, micro-electro-mechanical systems and control, where large-scale simulations have to be performed. The methods of model order reduction can be classified into several classes including proper orthogonal decomposition, reduced basis, balanced truncation, etc. Several MOR libraries have been well developed in MATLAB and Python. For instance, pyMOR is a Python library that relies on the application of reduced basis methods to parameterized partial differential equations. MATLAB's model reducer supports pole-zero simplification, balanced truncation mode selection methods and so on. In Julia, the main package that enables symbolic modeling is ModelingToolkit.jl, whose key features consist of automatic transformation and structural simplification, but it needs further works on fast ML approximate transformations. So this project is targeted on implementing MOR methods as extended features for ModelingToolkit.jl. Besides implementation of methods of model order reduction, the expected deliverables will include documentation which shows both the improved simulation time and accuracy penalty for the application of different MOR methods on test problems from various disciplines.
The BeamVision extension revolutionizes interactive pipeline development in JupyterLab by transforming fragmented notebook visualizations into an integrated workspace, as envisioned in the original design document. At its core lies a dynamic side panel that fundamentally reimagines how users inspect Apache Beam pipelines - consolidating previously scattered visualizations while preserving the documented backward compatibility requirements. This architectural shift directly addresses the project's stated pain points of vertical space consumption and redundant JavaScript code by implementing the described collapsible interface and centralized rendering system. The solution carefully balances innovation with technical constraints through a hybrid approach combining kernel-side HTML generation for reliability with frontend D3.js rendering for interactivity, both explicitly prioritized in the project's technical specifications. Beyond basic visualization, the implementation delivers on the documented cluster management capabilities, providing seamless Flink/Dataproc integration exactly as outlined in the side panel use cases. Every component maintains strict adherence to the original vision - from the multi-tab comparison interface described in the design workflow to the incremental data loading strategy for large datasets. By systematically executing the documented requirements without introducing unsupported features, BeamVision transforms the proposal's vision of "better UX when exploring pipeline states" into a production-ready reality while laying foundations for future extensibility through the approved plugin architecture. The result is a purpose-built environment that finally unlocks Apache Beam's full potential within JupyterLab, precisely as the project architects intended.
This project builds an end-to-end Handwritten Text Recognition (HTR) pipeline for early modern Spanish manuscripts by placing a Vision-Language Model (VLM) at the center of every processing stage, not just as a late-stage corrector. The pipeline uses Qwen2.5-VL with LoRA-based multi-task fine-tuning across four stages: document analysis, literal reading, line-level OCR via a fine-tuned TrOCR model, and reconciliation/correction, where the VLM reconciles multiple reading sources using visual and contextual evidence. As a pre-GSoC contribution, I have built and validated this pipeline, achieving a median CER of 0.107 (~89.3% character accuracy) on the Rodrigo dataset with perfect transcription on well-preserved pages. The proposed GSoC work will transform this into a production-ready, multi-model application by abstracting the VLM backend to support multiple open-source models (Qwen2.5-VL 3B/7B/72B, InternVL), adding batch processing for multi-page manuscripts with PDF support, building a locally-run desktop application with a Gradio interface, packaging the pipeline as a pip-installable CLI tool, conducting comprehensive benchmarks and ablation studies across all model backends, releasing fine-tuned model weights on HuggingFace Hub, and providing a training pipeline for researchers to fine-tune on their own manuscript collections. The fully local execution model ensures data privacy for sensitive archival material, while the multi-model architecture allows users to select models based on their hardware constraints and accuracy requirements.
Apache Beam through its unified model for batch and streaming data-parallel processing pipelines, runners for executing them on a variety of distributed processing backends and ML specialized transforms within MLTransform (such as EmbeddingManager and other MLTransformProvider) make it uniquely positioned for building out RAG (Retrieval Augmented Generation) based applications. These applications are one of the most useful and commonly being built applications on LLMs (Large Language Models). For this project we will focus on building a knowledge base on a vector database for a text corpus, and enriching user's questions with matching text chunks using semantic search. This is a crucial part of any RAG applications and helps us in building the right prompt context for LLMs. We will implement the following deliverables to achieve this: 1. Build a Beam pipeline that takes in a batch text corpus from a public dataset as parameter to pipeline and uses MLTransform to generate and save Embeddings in batch mode to a vector database. - Initial scope: Wikipedia dataset with JinaAI Embeddings read from object storage and written to RedisIO to publish to known vector DB. 2. Build a Beam pipeline that takes in stream of text questions from clients and enriches it with related texts from the vector DB. - Initial scope: KafkaIO based reading of queries which is populated by producers independently and published in a different topic for results. 3. New enrichment handlers for vector database queries over Redis based Vector DB Stretch goals: 1. Implement enrichment handlers for OpenSearch (AWS supported)[4] 2. Implement enrichment handlers for Vertex AI Vector Search (GCP Supported)[5] The goal is to demonstrate semantic search building capabilities trivially using Beam and hence evaluation of search results is not tied to a broad benchmark (such as MTEB) for this project's scope.
Sugar Activity on Demand addresses a key barrier in Sugar Labs: the difficulty learners face in creating their own activities due to the need for programming knowledge. This limits access to constructionist learning, where students learn best by building meaningful projects. This project introduces an AI-assisted system that allows learners to describe an activity in natural language and receive a fully functional, installable Sugar activity. The system combines a model-agnostic LLM pipeline, a retrieval-augmented knowledge base built from real Sugar Activity source code, and an AST-based validator to ensure that generated Python code is both correct and safe. Activities are generated with proper GTK3 interfaces, toolbar integration, and Journal support, ensuring they are fully compatible with the Sugar ecosystem. Beyond generation, the project emphasizes learning through a Reflective Studio, where learners explore, understand, and modify the generated code. Using scaffolded challenges, inline annotations, and reflection prompts, the system follows the constructionist Use → Modify → Create progression, enabling learners to gradually take ownership of their creations rather than passively consuming generated output. Deliverables AI-powered activity generation pipeline (prompt → plan → code → installable bundle) RAG-based knowledge system using real Sugar Activity examples AST-based security validation and safe code generation framework Interactive Reflective Studio with guided editing, annotations, and challenges Integration into Sugar’s Home View with a seamless “Create with AI” entry point Support for iterative refinement, version history, and sharing via the Sugar Journal This project aligns with Sugar Labs’ constructionist philosophy by transforming AI from a passive generator into an active learning partner, empowering learners not just to use software, but to understand and create it.
Volcano dashboard is a volcano resource front-end display tool. Currently, it only supports viewing resources, and the resources displayed are limited. It needs to support viewing more resources, and supports operations such as creation and deletion. Expected Outcome: 1. Supports viewing resources other than volcano related resources. 2. Supports add, delete, modify and query resources such as queues and volcano jobs.
Implement custom compiler transformation passes to fuse tensor math kernels on ARM and AVX architectures.
Project Light-OCR aims at providing lightweight OCR(optical character recognition) for the users of OpenCV. The whole process includes lightweight model selection(CRNN-CTC and DBNet), model quantization and converting model to ONNX.For less storage overhead and bandwidth requirements and faster computing speed ,the project provides lightweight OCR models which are quantized by QAT(quantize-aware training quantization) method using PPQ(PPL Quantization Tool). Proposed Deliverables:Quantized CRNN-CTC , DBNet and other lightweight OCR models in ONNX,all patches used in the project and a detailed document.