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.
<p>Gesture recognition becomes popular in recent years since it can play an essential role in non-verbal communication, emotion analysis as well as human-computer interaction. The research task is to detect hand gestures in raw news videos which are streams of RGB images. I propose a Transformer and keypoints-based pose tracking system and a Transformer and keypoints-based gesture detector to fulfill this task. This structure is composed of a keypoints extractor, a person tracker, and a gesture detector. The mission has three main parts, the first part is to track people in temporal space. In the second part, for each person, we use their hand keypoints features in temporal space to construct several keypoints sequences. The third part is to use these sequences to make predictions of the existence of gestures. I believe that for gesture detection tasks, both spatial and temporal information is important. So that is why we use the Transformer which can take into account the local information of hand keypoints in one frame to capture the shape information and it values also the relationship of keypoints in different frames that is the global information refer to the motion.</p>
<p>Basic functionalities which will lead to the completion of the project will be added in this proposal. <strong>Adding desktop browsers</strong> with options of <em>dimension change, zooming across the webpage</em> in both desktop and mobile browser, <strong>adding orientation mode</strong> for mobile browser. <strong>Adding a tag to website</strong> for <em>dynamic or static content</em>. <strong>Selecting advertisements</strong> in websites which will be trained on a <strong>Faster R-CNN model</strong> to mark them compatible in two screenshots. <strong>Training and testing different models on different types of queries</strong> ie, different types of web compatibilities as selected by user and <strong>maintaining a database with these results including machine information and training time along with the network architecture</strong>. Finally, create a <em>test.py</em> wich will <strong>collect screenshots in complete search fashion, chose from the database the best model</strong> for the given type of query and give result of <strong>percentage compatibility</strong>.</p>
<p><a href="https://www.softwareheritage.org/" target="_blank">Software Heritage</a> is an ambitious research project whose goal is to collect, preserve in the very long term, and share the whole publicly accessible Free/Open Source Software (FOSS) in source code form.</p> <p>The Software Heritage <a href="https://docs.softwareheritage.org/devel/swh-model/data-model.html" target="_blank">data model</a> is a big <a href="https://en.wikipedia.org/wiki/Merkle_tree" target="_blank">Merkle</a> DAG made of nodes like revisions, releases, directories, etc. It is a very big graph, with ~10 B nodes and ~160 B edges, which makes it hard to fit in memory using naive approaches. Graph compression techniques have been successfully used to compress the Web graph (which is slightly larger than the Software Heritage one) and make it fit in memory. The goal of this GSoC is review existing graph compression techniques and apply the most appropriate one to the Software Heritage case, enabling in-memory processing of its Merkle DAG.</p>
Multiple robotic spacecraft have been sent by NASA to collect orbital remote sensing data, which is used to analyze surface composition. Gamma-ray spectrometers are among the sensors used for this task. They collect position-dependent energy spectra whose shape is a function of the components from different elements present in the area observed by the sensor at a particular time. This data can be used to infer the relative abundance of each element (through a process called unmixing) and to map their distribution across a planet’s surface. However, accurately deriving abundance just from gamma-ray spectra is an intractable problem. Machine learning (ML) has been widely used to address intractable problems, including the unmixing of spectral signatures in the visible and near-infrared (VNIR) region of the electromagnetic spectrum. Therefore, this proposal outlines the development of an ML model for estimating elements from gamma-ray spectra. This goal consists of two sub-objectives: (i) identification of the best model/architecture using data from the Lunar Prospector Gamma-Ray Spectrometer (GRS); (ii) a trained model for estimating elemental abundances from GRS data.
Some of the most extreme and mysterious events in the universe like neutron star mergers, black hole accretions, and gamma-ray bursts are studied by the high energy radiations that they emit. Among all the brightness variations we can study in these sources, periodic and quasi-periodic oscillations are among the most interesting, because they can provide insights into the astrophysical processes in these objects. While the stingray package is a valuable tool for analyzing periodic data, its analysis of quasi-periodic data is limited by biases in frequency domain methods. To mitigate these limitations, a Gaussian process regression (a time domain method) can be used to model the time series for a kernel describing a QPO. Using Bayesian Inferencing, we can infer its parameters and assign them physical meaning related to the physics of the process and perform model selection between QPOs and alternative models. This can be used to reliably detect QPOs, and infer their physical properties. Such methods have already been implemented in recent papers (Huebner et al,2022), and the goal of this project will be to simplify their code and implement it in Stingray using the Tinygp library for the GP backend. It will also be accompanied by a tutorial and a demonstration on various datasets.
<p>tf.data.Dataset is the defacto way of loading and preprocessing data in TensorFlow for training machine learning models on CPUs, GPUs and TPUs. There are a range of advantages available with the tf.data API suitable for distribution of workers using various tf.distribute.Strategy(s). Whereas, the keras_preprocessing framework is popularly used to load and preprocess data for keras Model(s). It comprises a bunch of classes (inherited from keras.utils.Sequence) based on NumPy and SciPy implementations making it unsuitable for either multi-worker strategies or prefetching.</p> <p>Recently, TensorFlow has introduced the Preprocessing Layers API that allows preprocessing layers to be serialized with the model itself. It is fundamentally aimed at unifying the functionalities available within keras.preprocessing. In this project, we would implement the API specifications (related to image operations by implementing ImagePipeline class) as discussed in the <a href="https://github.com/keras-team/governance/blob/master/rfcs/20190729-keras-preprocessing-redesign.md" target="_blank">latest Keras RFC</a> which proposes changes and redesign of the Keras Preprocessing API in favour of performance and usability.</p>
<p>Coccinelle is a C-program matching and transformation tool developed for C programmers to write intuitive code manipulation rules. This tool was initially released for Linux developers who send patches on mailing lists, but it can also be applied to other projects. To describe matching and transformation rules in the source code with a patch-like appearance, Coccinelle employs a domain specific language called the Semantic Patch Language (SmPL), and attempts to manipulate the given C code based on the given SmPL rule. Although SmPL can provide many useful matching and transformation features, there are limits to the C matching patterns that the SmPL grammar can express due to the complexity of the C grammar. This is particularly the case for function headers, that involve complex types, annotations, etc that have been somewhat less tested by the users of Coccinelle. This project will study the current status and limitations of the handleability of function headers by designing and running a script that checks whether each function header in a given project can be parsed correctly and applying it to the latest Linux kernel. Based on the results, any detected problems will be fixed.</p>
The calorimeter, a key detector in Large Hadron Collider (LHC) experiments, measures the energy of particles interacting with detector materials. Particles emerging from collisions create cascades of secondary particles, or showers. Describing these processes requires precise simulation methods like the Geant4 toolkit. Machine learning (ML) techniques, such as generative modeling, offer a promising alternative. Recently, the Fast Calorimeter Simulation Challenge (CaloChallenge) spurred the development and evaluation of different models. Also, in High-Energy Physics (HEP), there has been an increasing interest in using Julia as a language for software development, for combining the ease of programming of interactive languages, e.g. Python, with the speed of compiled languages, e.g. C++. This project targets to assess Julia's machine learning ecosystem's maturity, in terms of availability and robustness of libraries and tools for deep learning. To this end, a selection of models from the CaloChallenge will be chosen for implementation in Julia, as well as the required functionality to enable training and evaluation of the networks. Ultimately, a comprehensive analysis will be conducted between Python/C++ and Julia implementations, considering training time, inference time and evaluation metrics from CaloChallenge.
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.
<p>In this project, a Speech-to-Text conversion engine on Chinese is established, resulting in a working application.</p> <p>There are two leading candidates for idea implementation:</p> <ol> <li>A Tensorflow implementation for Chinese speech recognition based on DeepMind’s WaveNet. Although WaveNet was designed as a generative model, it can straightforwardly be adapted to discriminative audio tasks such as speech recognition. The paper omitted specific details about the implementation, we can fill the gaps in our own way in this project.</li> <li>A Tensorflow implementation for Chinese speech recognition based on Baidu's DeepSpeech. Mozilla's DeepSpeech project is an open source Speech-To-Text engine, using a model trained by machine learning techniques. It is a well-known open source project on Github, therefore we can make our own breakthroughs based on the existing framework in this project.</li> </ol> <p>Since these two architecture are both based on Tensorflow, we can actually refer both of the architectures when designing our own network. In this project, we can use THCHS-30, Chinese news from two CCTV channels, two Hunan regional channels, and one Changsha local channel to train our model.</p>
The bayesplot package is a key tool in the Stan ecosystem for visualizing Bayesian analysis results. However, it currently lacks specialized visualizations for predictive checks of discrete and categorical outcomes, and some existing plots could be improved for better usability and accuracy. These limitations hinder researchers' ability to thoroughly validate their models against real-world data, particularly for discrete and bounded data types. This project aims to expand and refine bayesplot by implementing new visualization techniques based on recommendations from Säilynoja et al. (2025). Deliverables: New plotting functions integrated into bayesplot (e.g., ppc_density_bounded, calibration plots). Enhanced versions of existing functions (e.g., rootograms, residual plots). Comprehensive documentation with examples and guides. Unit tests for robustness and edge cases. Blog posts tracking progress and showcasing new features. By the end of the project, bayesplot will offer a more versatile and user-friendly toolkit for Bayesian model checking, strengthening its role in the Stan community. These improvements will empower researchers to diagnose and communicate model fit more effectively, advancing Bayesian workflows across disciplines like machine learning, statistics, and data science.
<p>Metabolic modeling has been interwoven with constraing-based methods. The value of randomized sampling in the framework of metabolic modeling has been proved itself over the years (see <a href="https://doi.org/10.1074/jbc.R800048200" target="_blank">Schellenberger and Pallson (2009)</a> and <a href="https://www.nature.com/articles/s41540-019-0109-0" target="_blank">Herrmann et al (2019)</a>). Aim of this project is to integrate the produced data and knowledge of these twenty (and more) years and make use of the randomized flux sampling method to evaluate the metabolic interactions retrieved. To this end, thousands of publicly available reference microbial genomes will be selected, and their automatic metabolic network reconstructions will be implemented. Based on these models, cross-feeding interactions algorithms will be performed for groups of species to extract key metabolic processes. New functions, implementing the recently developed <a href="https://hal.inria.fr/hal-03047049v2" target="_blank">Multiphase Monte Carlo Sampling (MMCS)</a> algorithm in the framework of the <em>dingo</em> library, will make use of the randomized flux sampling concept to evaluate the processes retrieved.</p>
The U.S. Forest Service's Aerial Detection Survey (ADS) program has produced tens of thousands of hand-drawn polygons marking forest health damage from aircraft. Due to GPS imprecision and flight geometry, these polygons have systematic spatial offsets of 50–500 meters from their true locations in NAIP satellite imagery. This project builds an automated pipeline to align ADS polygons with NAIP data, recovering historical annotations as a training dataset for forest health computer vision models. The GSoC work focuses on three objectives: (1) improve alignment accuracy through a learned refinement layer using self-supervised displacement estimation techniques from the mentor-provided references, (2) scale the pipeline to all ~48,000 Oregon ADS polygons to generate a weak training dataset, and (3) fine-tune a DeepForest model on the aligned annotations for NAIP-based forest health outbreak detection. Deliverables: an optimized alignment pipeline with quantitative evaluation, aligned polygon GeoPackage for Oregon ADS data, a computer vision model for forest health detection on NAIP imagery, and a blog post documenting the methodology for others to apply to their own datasets.
MUIOGO is an existing Flask and JavaScript application that provides a browser-based interface for running CLEWS energy-environment models. This project extends it in four directions. 1) Cross-platform hardening: fixing path assumptions, making configuration runtime-configurable, and setting up CI on macOS, Ubuntu, and Windows. 2) Building a full OG-Core UI module with parameter input forms, scenario management, run execution, and interactive Plotly results visualization, so that OG-Core has the same level of browser-based support that CLEWS currently has. 3) A coupled mode interface providing a guided workflow where one model's outputs feed into the other, with validation, multi-stage progress tracking, and combined results display. 4) A converging mode interface enabling iterative execution of both models until results stabilize, with live convergence charts, configurable tolerance, and early stopping. The project concludes with PyInstaller packaging for all three platforms, an automated GitHub Actions release pipeline, and user and developer documentation. Deliverables include a CI pipeline on three operating systems, working OG-Core standalone workflows, coupled and converging execution UIs, downloadable platform-specific installers, and complete documentation.
<p>Currently, TARDIS uses the pyyaml library to parse the configuration file and a complex, custom-made validator to validate it. The issues with the configuration system in its current form are many:</p> <ol> <li>Many conversions that should be done in the parsing phase are done in the validator.</li> <li>The validator implements many concepts which are already implemented in existing validating libraries.</li> <li>The validator comes with a custom schema which adds nothing to already existing well-defined and broadly-used schemas.</li> <li>The code which processes different input models for the construction of the final Configuration object is poorly-written.</li> </ol> <p>My project proposal is to improve the way the configuration system works by:</p> <ol> <li>Taking full advantage of the capabilities of pyyaml, by doing all the required type conversions in the parsing phase.</li> <li>Replacing both the validator and the schema with an existing, broadly-used library and format and using the library to the maximum extent in order to cover all the needs.</li> <li>Replacing the after-parsing code which processes different input models with a well-defined, easily extensible (with more input model formats) system.</li> <li>Documenting and testing all of the above.</li> </ol>
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.
OCSMesh is a Python package designed for generating unstructured meshes tailored to ocean modeling. However, its current workflow, particularly the Digital Elevation Model (DEM) processing and JIGSAW mesh generation steps, remains highly time-consuming and not well-optimized for High Performance Computing (HPC) environments. To address this bottleneck, I propose introducing parallelism into the most computationally intensive stages of the workflow: DEM processing and JIGSAW-based meshing. My approach involves leveraging parallel computing libraries such as Dask and mpi4py to scale these operations across multiple cores and nodes. For the preprocessing stage, several components are already optimized for single-node performance and can be extended to work efficiently in an HPC setting. Regarding JIGSAW meshing, I plan to implement a domain decomposition strategy, partitioning the domain into smaller subdomains that can be meshed independently in parallel. These subdomain meshes will then be seamlessly merged to form the final unified mesh. This parallelized workflow is expected to dramatically reduce mesh generation time, enabling more scalable and efficient processing for large-scale ocean modeling tasks. I aim to integrate mpi4py support into the key functions across the codebase, while using Dask specifically for raster windowing and DEM data handling.
This project will implement the recent techniques from Gallagher et al. (2024) and Gallagher et al. (2025) for improved time series simulation studies covering the whole parameter space of time series models (and not just cherry-pick one or two parameter settings) and also bring modern estimates of the acf/pacf and consistency in AIC selection of ar models (which is not currently available). Specifically, the project will: - create functions for acf and pacf estimation based on a dual shrinkage approach - create functions for ar estimation based on the dual shrinkage pacf - interface the new ar estimation function with standard methods such as AIC for consistent estimation - create new graphics for displaying these estimates that make clear to the user the effect of the dual shrinkage approach (as an option) - create functions to generate ARMA parameters that satisfy a correlation constraint (high/med/low or a fixed correlation strength) - create functions to generate random ARMA parameter values that cover the whole parameter space regardless of the model order - create a wrapper for the above two functions to generate simulation datasets for researchers in one line of code All this functionality will require appropriate documentation, testing and a vignette for users.
The MIFOS Payment Hub EE (PH-EE) is a microservice-based financial infrastructure requiring high availability, security, and resilience. However, systematic architectural testing—especially under failure and stress conditions—is currently limited. This project introduces an AI-driven testing framework designed to assess and improve PH-EE’s robustness by simulating faults, generating and analyzing synthetic logs, and applying machine learning models to detect anomalies and predict failures. Using tools like OpenTelemetry, Prometheus, Elasticsearch/Kibana, and Isolation Forest/Time-Series models, the framework will monitor service behavior, generate failure scenarios, and highlight weak points in system architecture. It will provide visual dashboards, anomaly tagging, and metrics to guide debugging and resilience improvements. Deliverables include: Architecture mapping and categorization of critical PH-EE components Synthetic log generation simulating realistic failure patterns Integration of AI-based anomaly detection models Dashboards and visualization for observability (Grafana, Kibana) A reproducible proof-of-concept and documentation This project will empower MIFOS developers and adopters with actionable insights to improve system health, scalability, and fault tolerance through intelligent architectural testing
I propose to improve the accessibility of Wagtail websites by enabling editors to add alt text to images. Currently, there's no clear way to do this, leading to inconsistent accessibility practices. My solution involves five main parts that are also my deliverables: (1). StreamField Block for Images: I will create a new block specifically for images that includes an alt text field. This ensures editors don't forget to add alt text. (2). Modifying the Image Model: I will add an "image description" field to the existing image model. This provides more flexibility for alt text. (3). Writing tests. (4). Updating documentation. (5). Exploring the use of AI to generate alt text suggestions (as a stretch goal, along with some other stretch goals in the PDF I attached). I plan to achieve the first two goals by building upon the pertinent Pull Requests I have already drafted at the time of writing this. Goals 3 and 4 will follow each of the first two goals closely, and I have commenced research on integrating AI models with inspiration from the Wagtail-AI GitHub repository. For goal 5, I plan on working hand in hand with the A11y team. This project will make Wagtail sites more accessible for visually impaired users and improve overall accessibility compliance.
Stochastic simulation is essential in computational biology and infectious disease modelling, but existing methods require a trade-off between accuracy and computational efficiency. While exact stochastic simulation captures dynamics in small populations, it scales poorly, whereas deterministic ODE models are efficient but fail to capture stochastic effects. The Jump-Switch-Flow (JSF) framework addresses this by dynamically switching between stochastic simulation and deterministic ODE integration based on population size. However, despite a mature Python implementation, R remains the dominant language in epidemiology and biostatistics, creating a significant accessibility gap. This project will develop rjsf, an R package that provides user-friendly functions for running the Python `jsf` library directly within R workflows via reticulate. Key deliverables include a core simulation function, S7-based result objects, diagnostic and visualisation tools, a comprehensive test suite, and a detailed vignette, with the goal of CRAN submission. As a stretch goal, the project will explore incorporating additional intermediate stochastic simulation methods to further enhance flexibility and performance. The resulting package will enable researchers and scientists to seamlessly integrate hybrid stochastic-deterministic simulation into their existing R-based modelling workflows.
ArviZ is a Python library for the exploratory analysis of Bayesian inference models. It is currently undergoing a major refactor into a modular structure comprising three sub-packages: arviz-base, arviz-stats, and arviz-plots. This refactoring brings changes to both the API and the internal implementation, with most of the design decisions already in place. The primary task that remains is migrating and reimplementing existing features from legacy ArviZ into the new structure. This project focuses on achieving feature parity in arviz-plots by reintroducing essential visualization tools from the original ArviZ while also enhancing them with new capabilities. These include plots for MCSE, t-statistics, parallel coordinates, quantile dot plots, support for circular variables in trace plots and rank distribution plots, among others. Additionally, new features such as a dark theme and improved rank plots with better envelopes for multiple sample comparisons will be incorporated. The goal is to implement and rigorously test these plotting functions, which are critical for model comparison, criticism, and sampling diagnostics. By ensuring that arviz-plots matches and improves upon the original functionality, this project will enhance the usability, maintainability, and extensibility of ArviZ. Ultimately, it will help strengthen ArviZ’s position as a go-to library for Bayesian model visualization and diagnostics.
Changepoint detection is widely used in modern data streams, but current regression based changepoint methods are limited in flexibility. Existing approaches typically assume that when a changepoint occurs, it affects all regression variables at the same time. This makes it difficult to model realistic scenarios where some components remain fixed while others change. This project aims to develop an open source R package implementing recent work on generalised changepoint regression, where users can specify both fixed and changing regression covariates. The approach builds on existing research level code, which will be refactored into a generic framework function capable of handling a range of regression models, including time series settings. The project will deliver a fully functioning R package with user-facing functions and supporting tools such as summary, print and plotting methods, designed to be consistent with existing changepoint packages. It will also include extensive testing, simulation functions for generating data, and clear documentation, with the goal of producing a CRAN ready package. Should time allow adding mixed effects or non-parametric regression models would be included. Overall, this project will provide a flexible and practical tool that addresses a gap in current changepoint methodology and will be useful for applied users.
<p>The proposal is inspired by the idea G on RedHen's GSoC 2016 idea page. The main purpose is to develop models and code helping domain experts to research on art history. It includes five main tasks:</p> <ol> <li>Training a classifier for recognizing a limited number of known visual symbols in images of religious artworks. VGG-net based fully convolutional network models will be trained for this task. Multi-scale detection, non-maximum suppression and bounding box regression will be implemented. </li> <li>Training a detector for localizing person heads and hands in images of art with various styles. CNN models will be trained based on a state-of-art head detection method.</li> <li>Building a module identifying a few certain hand gestures in images of artworks based on task 2. With the cropped detection result of task 2, a classifier based on VGG-net will be built.</li> <li>Developing a tool generating a frontal view of a face given a artistic portrait with a side view of the face based on existing face frontalization code. </li> <li>Developing initial research code for analysis of color style changes over time of Christian paintings by machine learning.</li> </ol>