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 implement the Fourier Neural Operator (FNO) in DeepChem, expanding its support for solving complex partial differential equations (PDEs) in scientific machine learning. Traditional neural networks often struggle with PDEs due to their reliance on fixed-grid discretization. FNO addresses this by operating in the frequency domain, learning resolution-invariant mappings between function spaces using the Fourier transform, making it both scalable and efficient. The project involves developing a new SpectralConv layer and a high-level FourierNeuralOperator class compatible with DeepChem’s PyTorch backend. The implementation will be modular, enabling future extensions such as Physics-Informed Neural Operators (PINO). Deliverables include the FNO model, unit tests, and a comprehensive tutorial.
The Mifos and Apache Fineract platforms, while offering comprehensive core banking solutions, present challenges in documentation due to their technical complexity and extensive domain-specific knowledge. To address this, the proposed project aims to leverage a class of large language models (LLMs) based on transformer architectures(especially reasoning based), to enhance documentation accessibility and user support. Building upon a preliminary LLM developed in 2024, the 2025 initiative will focus on scaling this system across the full documentation set, which involves scraping all the necessary sites,sublinks,slack channels and even youtube videos via their transcripts. This new project aims to completely revamp the way a normal Q&A chatbot does by leveraging state of the art models and latest techniques.
SOFIE generates standalone C++ inference code from trained neural networks, letting HEP frameworks run ML models without heavy external dependencies. Its integration with the alpaka library enables portable GPU inference that works across NVIDIA, AMD and CPU backends from a single codebase. The current GPU path covers basic operations but lacks support for several key operators needed to run full neural networks on GPU. This project implements the missing GPU kernels and extends convolution to handle batched inputs, so complete CNN architectures can run end-to-end on GPU through SOFIE. The final goal is a ResNet-style model running fully on the alpaka GPU backend and validated against the CPU reference.
Maths-Mantra is an inclusive Android math learning app designed for visually impaired and sighted learners, transforming the way mathematics is explored through touch, sound, and interaction. Building on a foundation of accessible learning, the app introduces Quick Play, Learning Mode, and additional game modes, offering varied, engaging experiences for learners of different skill levels. It integrates device sensors such as the gyroscope, accelerometer, and multi-touch inputs to make geometry, number lines, and spatial concepts interactive and tangible. With gesture-based navigation, audio-tactile feedback, adjustable difficulty levels, and localization support, Maths-Mantra creates a multi-sensory, barrier-free environment that empowers students to understand and enjoy mathematics in a playful, engaging, and fully accessible way.
This project accelerates the convolution core of the Active Segmentation Plugin (ASP) in ImageJ by offloading its most compute-intensive pixel operations to parallel hardware using TornadoVM. The goal is to achieve significant speedups without altering existing functionality or behavior. The approach focuses on identifying CPU bottlenecks, converting them into accelerator-friendly kernels, and executing them through a reusable TornadoVM pipeline. A strict correctness-first methodology ensures all accelerated outputs match the CPU reference in terms of boundary handling and numerical accuracy before any performance gains are considered. By integrating a robust, reusable parallel execution layer with safe CPU fallback, this work transforms ASP’s performance while preserving its reliability—laying the foundation for scalable acceleration across multiple filters and larger image-processing workflows.
<p>The <a href="https://jupyter.org/" target="_blank">Jupyter Notebook</a> is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations, and narrative text. To interactively work with Octave code within Jupyter Notebooks, there already exists an <a href="https://github.com/Calysto/octave_kernel" target="_blank">Octave kernel for Jupyter</a>. This project aims to support the opposite direction: running (and filling) Jupyter Notebook within GNU Octave. This would enable Jupyter Notebook users to evaluate long-running Octave Notebooks on a computing server without a permanent browser connection, which is still <a href="https://github.com/jupyter/notebook/issues/1647" target="_blank">a pending issue</a>.</p>
Pharo provides an immersive and interactive development environment with powerful refactoring tools. However, its current refactoring workflows can be fragmented, rely on frequent pop-ups, and offer limited feedback, making them less user-friendly. This project aims to improve the usability and interactivity of Pharo’s refactoring tools, with a focus on rename operations. To achieve this, the project will develop a flexible driver and preview infrastructure that supports safe experimentation, introduce live name editing with immediate validation, and enhance the visualization of changes through a hierarchical tree structure. The expected outcomes include a streamlined refactoring workflow, a clear hierarchical preview of all changes, real-time validation of user input, and a more intuitive and interactive user experience that helps developers better understand and manage code transformations.
This project aims to enhance Sysprof by integrating eBPF-based profiling to reduce overhead and improve performance. Currently, Sysprof relies on accessing numerous /proc files, which involves frequent syscalls, file descriptor operations, and context switches, creating performance bottlenecks. By utilizing eBPF, data collection can be done directly within the kernel, eliminating the need for constant /proc access and minimizing context switches. This approach not only lowers overhead but also ensures consistent and atomic data capture. eBPF also allows for advanced features such as system-wide syscall monitoring and process creation tracking, which were difficult to implement previously. By adopting eBPF, Sysprof becomes more efficient, scalable, and feature-rich, laying the foundation for future enhancements and transforming it into a modern, versatile profiling tool.
In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation. The AD library is able to differentiate non-trivial functions, to find a partial derivative for trivial cases and has good unit test coverage. Vector mode support will facilitate the computation of gradients using the forward mode AD in a single pass and thus without explicitly performing differentiation n times for n function arguments. The major benefit of using vector mode is that computationally expensive operations do not need to be recomputed n times for n function arguments.
ModelHamiltonians is already a well-structured library to express and simulate Hamiltonians in the context of quantum chemistry. The package, however, lacks some manipulations of the Hamiltonians that can be useful to researchers to efficiently manipulate and analyze electronic structure calculations while maintaining the flexibility to work with different standard theoretical frameworks. To address this, this proposal is related to the creation of a toolkit module that will mainly allow: 1. Atomic Orbital to Molecular Orbital transformations, generalizing to all Hamiltonians are available in the library; 2. Conversions to the geminal basis, enabling researchers to work with alternative representations of Hamiltonians for specialized applications. 3. Reduced Density Matrix (RDM) manipulations, improving the usability of ModelHamiltonians in many-body representations. 4. Add support for FCIDump file format reading and writing 5. Develop an interface with PySCF and write tests for all implemented functionalities.
The noaa_coops package provides oceanographic data access but has critical gaps: large date ranges fail without pagination, no retry logic for rate limiting, and NOAA's Derived Products are inaccessible. I will implement: (1) automated pagination respecting product-specific API limits, (2) throttling-aware retry logic with exponential backoff, (3) complete derived product support via a new method, (4) metadata retrieval fixes for historic current stations, and (5) numpy 2+ compatibility fix. Deliverables include a strengthened noaa_coops package with merged PRs addressing each issue, comprehensive pytest coverage (>90% for new code) and updated documentation with clear examples. This will transform noaa_coops into a production-ready package that oceanographers can rely on for large-scale research workflows.
<p><strong>Mobile Wallet</strong> is an Android-based framework for digital wallet use cases based on top of the Apache Fineract 1.x platform. The project follows the clean architecture and contains a core library module which can be used as a dependency in any other wallet based project. The Mobile Wallet framework currently has MifosPay as a reference application to demonstrate these use cases.</p> <p>This year we majorly focused upon the deeper integration with the external payment systems including Mojaloop, USSD via Hover SDK, and better support for merchant transactions. Further, we laid the foundation of transforming the Mobile Wallet framework to consume Apache FineractCN APIs instead of Fineract 1.x. Work was also done to improve the user interface, user experience, and overall aesthetics of the Android application.</p>
<p>In this project, I am trying to implement some deep learning modules which are used for classification. I am trying to implement some important modules like Radial Basis Kernel SVM, Radial Basis Function Network and Deep belief Nets.<br> Deep belief nets:- They are probabilistic generative models that are composed of multiple layers of stochastic, latent variables. The latent variables typically have binary values and are often called hidden units or feature detectors.</p> <p>Radial Basis Function Network:- It is an artificial neural network that uses radial basis functions as activation functions. The output of the network is a linear combination of radial basis functions of the inputs and neuron parameters.</p> <p>Radial Basis Function Kernel:- It is also called the RBF kernel, or gaussian kernel, is a kernel that is in the form of a radial basis function (more specifically, a Gaussian function).</p> <p>We can use these deep learning classification modules for various purposes like speech recognition, handwriting recognition, biometric identification, document classification etc.</p>
This project transforms API Dash into a next-generation, AI-native API client. I am merging three core objectives: 1. Agentic API Testing, 2. MCP Support 3. Generative UI Visualizations into a unified Dual-Transport Model Context Protocol (MCP) Architecture: 1. Agentic Sandbox & Generative UI (GenUI): Eliminating brittle WebViews, the internal UI will utilize Google's genui SDK and the Open Responses specification. This powers two features: an autonomous, self-healing Agentic Testing Dashboard, and a "Generative UI Previewer" that visualizes rich AI responses for end-users building Flutter/Web apps. 2. Headless MCP Engine: This exposes API Dash as a standard stdio MCP Server for external Agent interfaces (like VS Code, Cursor, or Claude Desktop).
<p>Open Tiled Manycore System-on-Chip (OpTiMSoC) is an open-source framework that allows one to design and prototype manycore-based platforms on FPGA devices. In its current status, OpTiMSoC offers wide support for experimenting different architectural-level configurations. However, when comes to benchmarking the prototyped platform at software-level, current runtime libraries and operating systems still have to be improved. To address this problem, the goal of this project is integrate OpenRISC Linux Port into OpTiMSoC. To do so, a new manycore configuration with a Host Tile will be designed and implemented. The Host Tile will run OpenRISC Linux and will be able to communicate with Gzll kernels running on Computing Tiles via message-passing through the Network-on-Chip (NoC). Overall, the communication infrastructure will be exported to user-level through standard UNIX file system operations.</p>
Graph Neural Networks (GNNs) are powerful tools for processing graph-structured data, with applications spanning social networks, recommendation systems, molecular modeling, and beyond. The Julia package GraphNeuralNetworks.jl, based on Flux.jl, provides access to common graph convolutional layers, offering a flexible framework for building GNN models. Sparse computations are essential for the efficient implementation of GNNs, since many operations, such as propagating node features, can be expressed as the multiplication of a sparse adjacency matrix with a dense feature matrix. Improving these operations through enhanced GPU kernels and fused operations is critical to reducing memory overhead and increasing the overall performance. This project aims to address these limitations by enhancing CUDA.jl’s sparse matrix support and integrating these improvements into GraphNeuralNetworks.jl, ultimately enabling faster and more scalable GNN computations in Julia.
This project aims to enhance the performance of Generative AI (GenAI) workloads on ARM devices using the OpenVINO toolkit, focusing on reducing latency and throughput metrics, accelerating model compilation times, and minimizing memory requirements. The initial phase involves establishing a robust benchmarking environment tailored for GenAI models, employing tools such as Flame Graphs for performance visualization and monitoring tools for memory usage analysis. This setup will enable rapid assessment of optimizations' impacts on performance and resource consumption. Refine and enhance the performance of Generative AI workloads on ARM devices, targeting the OpenVINO toolkit. The project will concentrate on advanced optimization techniques not yet fully explored or implemented in the OpenVINO ecosystem for ARM architectures, specifically focusing on graph transformations, low-level kernel optimizations, and enhanced utilization of the ACL (Arm Compute Library).
I plan to make BRL-CAD python bindings. Basically my goal is to make a Python interface for BRL-CAD using MOOSE as the core modeling backend, with a thin C bridge between Python and C++ for stability and portability. The architecture is: Python interface -> moose_rt3 adapter (ctypes) -> C bridge -> MOOSE C++ API -> BRL-CAD database engine -> .g file. I plan to work around 3 goals: 1. Database lifecycle behavior should be consistent across read-only, writable and in memory modes with clear errors when operations are invalid 2. Core primitives and CSG operations should be exported correctly and transforms must be stored as combination-member matrices so results are verifiable by MGED. 3. Unified read access: provide one Python read entrypoint for supported object families with a stable return format and desterministic errors for missing or unsupported objects
The project’s goal is to evaluate results from checkpatch.pl, aggregate its findings and improve checkpatch.pl based on the evaluation. The checkpatch.pl script detects various coding style issues and checks for various stylistic conventions on commit messages and supporting information, e.g., consistent records of MAINTAINERS, license information, proper file permissions, etc. However, an earlier investigation on checkpatch.pl has shown that many patches in the kernel repository are accepted, even though checkpatch.pl reports findings on them. Some of those checkpatch.pl errors and warnings are “false positives”. The work in this project shall be driven by a continuous, highly iterative cycle of evaluation on large sets of commits and patches, machine-assisted aggregation and clustering to identify specific community-local conventions, and adjustment and configuration of the checkpatch.pl script. The repeated evaluation will prioritize the specific changes to checkpatch.pl.
The current OWASP Snapshot system is passive and requires manual updates, forcing community members to constantly check the website to see what has changed across the organization. This project solves that problem by transforming snapshots into an active, automated digest platform. I will build a system that automatically collects weekly updates expanding the scope to include events, blog posts, and pull requests and delivers them directly to interested users. Contributors will be able to customize their subscriptions, choosing exactly which projects and data types they want to follow. I will also redesign the website's snapshot pages to support date-range filtering, full content display, and social sharing. The core architecture will prioritize GraphQL for all frontend needs. The primary deliverables are the automated processing pipeline, the personalized email newsletter system, subscription management, and the enhanced web interface. A snapshot feedback system and supplementary REST endpoints are planned as stretch goals.
The current state-of-the-art tracking models are hampered by low speed, limiting their applicability on devices with limited computational power. Although Existing realtime object tracking models could reach high speeds on edge devices, their performance is poor. Consequently, the high-performance tracker with fast speed on edge devices is critical. I have two plans to solve this problem. The first Scheme is to use the pre-trained lightweight transformer as the tracking models' backbone and through the proper design, the tracking model not only has good performance because of the use of the pre-trained visual transformer but also because the visual transformer used is lightweight and does not slow down the model due to the huge amount of computation caused by the transformer. The second Scheme is to build a small tracking model and pre-train the small tracking model using the MAE pre-training method, and finally, choose the current best-performing transformer-based tracking model as the teacher model to train the student model. Eventually, two state-of-the-art real-time tracking models will be provided, along with their code, and they will be maintained over time.
This study focuses on the spatio-temporal dynamics of forest wildfires in Fairbanks under a changing climate. The research aims to analyze the patterns, causes, and impacts of wildfire occurrences using geospatial techniques. Satellite data such as Landsat and MODIS will be used to derive key indices including NDVI and NDMI to assess vegetation health and moisture conditions. Land Use/Land Cover (LULC), slope, aspect, wind speed, temperature, and rainfall data will be integrated within a GIS environment. Temporal analysis will be conducted to identify trends in temperature and precipitation, while change detection techniques will be applied to evaluate landscape transformations. A fire susceptibility map will be generated using a multi-criteria decision analysis approach to identify high-risk zones. The study will also examine the relationship between climate variability and wildfire frequency. The results will support early warning, risk assessment, and effective wildfire management strategies in the Fairbanks region.
For broadcasting messages, mailing lists are essential but high traffic lists frequently fill the inboxes with replies to threads of a particular topic that subscribers have no interest in. This project introduces Dynamic Sublists into the GNU Mailman 3 suite. This is an ideal feature for user-support community groups or for issue tracking where topics of interests/specific tasks diverge from the main discussion thread. The earlier rigid broadcast model is transformed into an opt-in thread model, ensuring only the root email of a new topic is broadcast to the main mailing list, after which the next round of replies will be routed strictly to a child list, delivering the mail to users who have explicitly opted in. Sublists are treated as dynamically made child MailingList objects linked via a parent_id. This project requires implementation across Mailman 3 Core, extending the SQLAlchemy IMailingList schema, implementing inheritance, building the email command workflow (-new to fork threads and standard -join/-leave aliases), and adding an admin specific toggle for Postorius.
This project introduces a ‘Cold Start’ Data Factory that turns zero/one-shot prompting into a full data-to-training workflow. The core contribution is a production-grade DatasetWriter pipeline that converts inference outputs into validated, reproducible annotations, supports format-aware serialization, and guarantees reliable flushing/finalization for large export jobs. The generated datasets can be exported in standard formats such as YOLO, COCO, and CVAT, with quality statistics and filtering controls for practical downstream use. Building on that, the project adds direct OTX training integration: once export is finalized, the system can automatically generate training configs, spawn OTX runs, stream logs/status, and track artifacts and run metadata. This shifts geti-instant-learn from a live-inference-only experience to a complete cold-start bootstrapping system where prompt-based “Teacher” labels are transformed into trainable “Student” datasets and model training jobs. The result is a faster and more reliable path from a few prompts to deployable edge models.