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 addresses the challenge of fast and accurate particle detector simulation in high-energy physics. Traditional Monte Carlo methods are highly accurate but computationally expensive, while existing fast simulation techniques often compromise on physical fidelity. The goal is to develop a model that achieves both high accuracy and significantly lower computational cost. Building on my GSoC 2025 work, I propose to extend a graph-based generative pipeline where particle jets are represented as graphs and processed using Graph Neural Networks (GNNs). The current architecture includes a Distance-based ChebNet encoder, a deterministic latent bottleneck, a physics-aware cluster decoder, and a conditional flow matching model with FiLM conditioning. A key innovation is that generation occurs entirely in a fixed 512-dimensional latent space, making computation independent of the number of particles and substantially more efficient than existing methods. For GSoC 2026, the focus is to refine this pipeline to publication quality. This involves improving key physical observables such as multiplicity, jet mass, and particle momentum using better loss functions and physics-based constraints. I will also integrate a more stable ChebNet and perform ablation studies to validate architectural choices. The project will include rigorous benchmarking against state-of-the-art models like EPiC-FM, EPiC-GAN, and PC-JeDi using metrics such as Wasserstein distance, FPND, and generation time. Deliverables include an optimized pipeline, detailed evaluation and ablation studies, an open-source implementation, and submission to venues like NeurIPS ML4PS.
This project aims to develop a calibre plugin for bookbrainz. It will be used to update metadata of calibre books and add public collections or editions from bookbrainz directly in calibre.
This project addresses the challenge of bringing 3D-generated marine organisms to life through scalable and automated animation. While recent advances enable the generation of detailed 3D models, these assets often lack realistic motion and require manual rigging and keyframing, limiting their usability in interactive and educational applications. To solve this, the project proposes a skeleton-based procedural animation system built using Python, Blender, and Unity. The system will automatically generate rigs and apply biologically inspired motion using procedural techniques such as kinematic chains and wave-based movement, enabling consistent animation across a wide range of marine organisms. The final deliverables will include a modular animation pipeline, support for multiple movement behaviors (e.g., swimming and idle states), integration with existing 3D generation workflows, and documented demos showcasing real-time visualization in Unity.
This project aims to bring modern, decentralized communication to KolibriOS through the development of a native Matrix messaging client. Since the Matrix API requires HTTPS for secure data exchange—a capability not currently supported in the OS—the first phase involves porting Mbed TLS 4.0.0 and integrating it directly into the networking stack. This foundational work enables secure authentication and real-time syncing for the Matrix client while providing a reusable TLS 1.2/1.3 framework for other KolibriOS applications. The final result will be a fully functional client and a robust encryption library that upgrades the security standards of the entire operating system.
Currently, Oppia translates non-user-generated content via translatewiki and some user-generated content via the contributor dashboard. This project aims to extend the contributor dashboard's infrastructure to support translating exploration metadata (titles, tags) and skill (concept card) content. The solution involves building a highly extensible backend translation framework to display translation opportunities, surface reviewable suggestions, and display accepted translations to learners. Deliverables include migrating existing translation support to this new modular infrastructure (Milestone 1) and adding full support for metadata and skill content while removing legacy code (Milestone 2).
The Crossflow Diagram Editor is a workflow authoring tool, but today some core interactions around building and validating workflows can be improved to make editing faster and clearer. This project will improve the editor’s UI/UX by making connection authoring more intuitive, providing stronger real-time feedback for valid and invalid connections, and polishing key flows such as running, testing, and resetting workflows. The project will focus on improving correctness, responsiveness, and discoverability while building on the existing frontend validation and editor architecture. Deliverables will include improved drag-and-drop interaction feedback, filtered add-operation suggestions, more responsive run/test dialogs, additional automated tests for key editor behaviors, and updated documentation/demo materials. These improvements will make Crossflow easier for both new and existing users to adopt and will provide a stronger foundation for future validation and execution-time tooling.
OpenWISP Firmware Upgrader currently requires users to manually enter metadata when uploading firmware images, which is error prone and doesn't scale. This project adds automatic metadata extraction that runs as a background Celery task on upload, using fwtool as the primary method and DTB parsing as a fallback, with graceful handling for images that support neither. A draft/confirmed state machine keeps unverified images invisible to the upgrade system until extraction succeeds or an operator manually confirms the metadata. The implementation follows the existing upgrader class pattern for extensibility, includes full test coverage using real OpenWrt images, and adds build-level status aggregation with notifications.
mARine currently lacks a dynamic, reproducible environment system. This project builds a seed-based procedural generation pipeline that creates consistent marine terrain and living coral ecosystems across devices. A deterministic noise system shapes the ocean floor using fractional Brownian motion, cluster-based placement populates it with seven coral species using slope filtering and raycast confirmation, and a rule-driven simulation governs growth, bleaching, reproduction, and die-off — all emerging from agent interactions rather than scripted behavior. The same seed always reconstructs the identical environment without storing any state, making it practical for mobile AR. Deliverables include: chunk-based terrain streaming, a per-agent coral lifecycle system, URP underwater rendering (caustics, volumetric fog), and Unity Job System optimization for real-time mobile AR performance.
This project aims to integrate DICOM Query/Retrieve functionality into InVesalius, enabling direct communication with PACS servers. The implementation will include C-ECHO for connection verification, C-FIND for querying studies, and C-GET/C-MOVE for retrieving imaging data. The system will be built using pynetdicom and integrated into the existing InVesalius architecture with asynchronous processing to maintain GUI responsiveness. A working Proof of Concept has already been developed, and initial implementation has begun through an active pull request. The final deliverables include a PACS communication module, integrated query interface, retrieval pipeline, configuration panel, and supporting documentation.
Jitsi Meet confines all conference content to a single browser window, leaving second monitors completely unused. Presenters cannot see the audience while screen sharing, moderators cannot watch the gallery while focusing on the active speaker, and educators cannot monitor student reactions while presenting. This project uses the Window Management API and React createPortal to open a coordinated secondary browser window on a different physical display while sharing the same Redux store and WebRTC connection. Each window can display an independent layout such as active speaker view or gallery view with no duplicate participants and zero extra bandwidth. The implementation includes smart screen detection via getScreenDetails, per tile video track management with stale frame prevention, a four tier active speaker priority chain using real time audio levels, responsive gallery grid with ResizeObserver, two tier style inheritance, and full window lifecycle management including conference leave cleanup. A working proof of concept with active speaker video, gallery view, layout switching toolbar, and speaking indicator borders is already integrated into the Jitsi codebase.
This project aims to improve Rein, a LAN-based remote control system, by addressing its limitations in input injection and real-time communication. The current system relies on tools like nut.js and ydotool, which lack compatibility and extensibility, especially on modern Linux environments. To solve this, the project proposes a kernel-level virtual input device system using Rust for native and reliable input handling. Additionally, a WebRTC-based communication architecture will be introduced to reduce latency and improve real-time interaction. These improvements will enhance performance, cross-platform support, and prepare Rein for a stable production release.
Problem: Imbalanced datasets pose a significant challenge in machine learning, where standard metrics like accuracy can falsely evaluate a model that simply predicts the dominant class. Currently, the R community lacks a comprehensive and unified framework for handling imbalanced data and X-Risks problems natively integrated into the mlr3/mlr3torch ecosystem. Solution: This project, mlr3torchAUM, provides a comprehensive solution for imbalanced classification in R. It will bridge the current gap by integrating state-of-the-art loss functions, advanced evaluation metrics, and various data sampling techniques directly into the mlr3/mlr3torch pipeline. Deliverables: 1. State-of-the-Art Loss Functions: Implementation of algorithms including log-linear all-pairs squared hinge loss, Area Under Min (AUM) loss, and cost-sensitive logistic loss. 2. Sampling Operators: A robust suite of over-sampling techniques including SMOTE and ADASYN, alongside under-sampling techniques, all implemented safely under a `lazy_tensor` mechanism to avoid memory issues. 3. Advanced Evaluation Metrics: Integration of Precision-Recall curves, Macro/Micro AUM/AUC, and MCP/IMCP to fully support multiclass imbalanced scenarios. 4. LibAUC Integration: Porting cutting-edge losses and optimizers from the Python LibAUC library into R. 5. Engineering & Release: Comprehensive Test Driven Development, GitHub Actions for CI/CD, detailed vignettes, and a final submission to CRAN.
This project will build a native printer setup tool for the COSMIC desktop. It will add a Printers page in Settings and an Add Printer flow for legacy or specialty devices. The goal is to give COSMIC a modern printer management experience that matches the move toward IPP and Printer Applications in the Linux printing stack. I plan to implement it in Rust inside the cosmic-settings workspace, with a backend layer that keeps the UI stable as CUPS and Rust bindings evolve. The main view will show and group printer destinations, display status and default-printer information, and provide access to device web interfaces. The Add Printer flow will focus on finding legacy devices, suggesting suitable Printer Applications, and refreshing the main view after setup. Deliverables include a working Printers page, grouping and de-duplication logic, web-interface actions, an Add Printer workflow, tests, and documentation.
MLIR already makes allocation and deallocation structure explicit after bufferization and the ownership-based deallocation pipeline, but it still lacks an upstream static memory planner that can analyze buffer lifetimes and safely reuse memory for well-structured workloads. This is especially valuable for structured ML, HPC, and accelerator-oriented compilation flows where dynamic allocation is expensive or undesirable. I propose to build this in two incremental steps. First, I will implement an analysis pass that identifies eligible memref.alloc / memref.dealloc patterns, performs alias-aware lifetime analysis, computes planning metadata such as size and alignment, and reports reusable candidates and skip reasons. Second, I will build a conservative rewrite pass that rewrites eligible dynamic allocations into memref.subview-based slices of one or more statically allocated arena memrefs for legality-gated v1 cases. The main deliverables are: an upstream analysis pass for static memory planning, a conservative v1 rewrite pass for same-block structured cases, memory-space-aware planning support, strong lit/FileCheck coverage, documentation of supported and unsupported cases, and an incremental PR series that is realistic to review and land upstream.
Strong gravitational lensing is a powerful probe of dark matter structure and cosmology, yet no foundation model exists that is purpose-built for lensing data with theoretical training guarantees. This proposal introduces WaveLens-JEPA, a self-supervised vision foundation model for gravitational lensing that extends LeJEPA (Balestriero & LeCun, 2025) to the astrophysical domain. The core idea is to decompose lensing images using a 2D Discrete Wavelet Transform before encoding, separating the physically meaningful frequency scales — Einstein ring morphology, subhalo perturbations, and ALP vortex structure — into orthogonal channels. A physics cross-attention module injects convergence-map priors from the lensing equation at every ViT block, while Einstein-Ring-Aware Masking (ERAM) targets the physically informative annular region during pre-training. Fourier phase regularization preserves substructure-discriminative spatial information that standard encoders discard. The training objective inherits provable collapse-free guarantees via Sketched Isotropic Gaussian Regularization (SIGReg), unlike all prior lensing SSL methods. The pre-trained backbone is evaluated on six downstream tasks: two substructure classification setups, lens finding, mass density regression, super-resolution, and a novel interpretability task via Wavelet Attribution Maps (WAM). Deliverables include: (1) open-source modular codebase, (2) pre-trained backbone weights on Hugging Face Hub, (3) a six-task evaluation benchmark, (4) a sim-to-real domain adaptation protocol targeting COSMOS HST data, and (5) a full research paper.
This project aims to integrate bytetrack algorithm into a Mediapipe graph using OpenVINO inference calculators. The bytetrack graph will be deployed on OpenVINO model server to perform efficient object tracking on a video input. The deliverables of this project include a bytetrack graph in OpenVINO mediapipe fork with custom calculators, YOLOv10 model and bytetrack graph packaged in OpenVINO model server, and a Python client for the bytetrack graph to perform bytetrack algorithm on video stream. The final phase of this project includes evaluation of bytetrack on metrics MOTA, IDF1, and HOTA. The goal of this project is to bring the bytetrack algorithm to OpenVINO model server to leverage its efficiency, scalability, and robustness for production-grade inference.
The Mifos X WebApp is a powerful tool but it can be hard for people to use every day. A lot of institutions have a tough time with it because it is complicated and not easy to navigate, which slows down the people who work there. This project wants to make that better by putting an AI Assistant right into the Mifos X WebApp. The Mifos X WebApp will have an AI Assistant. You can think of the AI Assistant as a place where users can type what they need in language like finding a client making a loan or looking at a transaction and the AI Assistant will take care of the rest. The AI Assistant is powered by a kind of computer program and it talks to Apache Fineract through the Mifos MCP server. The AI Assistant also works with both cloud-based and on-premise models using Ollama so institutions that need to keep their data in their buildings can do that too. The main things we want to achieve with this project are an Angular chat interface built into the Mifos X WebApp, the Mifos MCP server integration, for calling Apache Fineract APIs in a way, an LLM layer that works with both cloud and local models, answers that are based on the current client, loan or user role, and good documentation and tests to go with the Mifos X WebApp and the AI Assistant.
This project aims to improve and evaluate symbolic regression methods for discovering interpretable mathematical models of biological network dynamics. A key challenge in this area is that, when working with real biological data, the true underlying equations are unknown, making it difficult to assess whether equation-discovery algorithms are accurate or biologically meaningful. To address this, I will generate synthetic time-series datasets from curated mechanistic models available in the BioModels database (e.g., SBML models), where the ground-truth equations are known. These datasets will be used to systematically evaluate and benchmark symbolic regression approaches, including PySR and neural-symbolic methods such as the Learning Law of Changes (LLC) framework. The project will also explore strategies to improve model identifiability and interpretability, including constrained search spaces and incorporation of biologically informed functional priors. The expected deliverables include: (1) a reproducible pipeline to generate simulation data from SBML models, (2) an evaluation framework to benchmark symbolic regression methods on equation recovery tasks, (3) implementation and comparison of PySR and LLC-based approaches, (4) strategies to address identifiability challenges in biological data, and (5) well-documented, open-source code integrated with existing SBML compatible tools.
Agentic AI is commonly used to predict and resolve problems before they occur, requiring access to data in near real-time. However, traditional patterns for reacting to data changes come with major disadvantages, exacerbating the challenge of building resilient, near real-time distributed systems. These patterns include polling, which is simple to implement but has a fundamental tradeoff between minimizing load on data sources and minimizing data staleness. Change data capture (CDC) avoids the aforementioned issues, but requires teams to build and maintain custom infrastructure. Using Drasi’s ability to track derived entities (via Continuous Queries) and Dapr Agents’ out-of-the-box durability for agents and agentic workflows, this proposed integration would help developers build scalable, event-driven AI systems in products and internal platforms. To accomplish this, Drasi would need a new ”proxy” service that routes events to multiple publish-subscribe (pub/sub) topics. Dapr workflows and agents would consume from these topics via workflow decorator functions and agent middleware, supporting Drasi and providing the groundwork to integrate other backends.
EventHorizon is a multi protocol IoT tarpit framework designed to trap automated network scanners. However, its current static deception mechanisms make the system predictable and allow scanners to fingerprint and evade the tarpit. This project solves this problem with a bio-inspired deception engine that adapts biological strategies such as camouflage, bluffing, and playing dead to low interaction IoT protocols. Furthermore, it modernizes the observability by migrating its telemetry to OpenTelemetry for cross-protocol trace correlation and structured data analysis.
This project aims to transform OCSMesh into a truly HPC-native tool by migrating its parallel architecture to mpi4py for distributed computing. Furthermore, I will implement a robust spatial partitioning engine that utilizes "windowed" data reading. This will decouple the meshing performance from the physical file structure, allowing OCSMesh to process global-scale datasets across supercomputing clusters without memory bottlenecks.
This project addresses the absence of HTTP streaming support in the Rage framework, where responses are currently fully buffered before being sent to the client. This limitation prevents real-time use cases such as incremental LLM outputs, live data feeds, and large streaming responses. Even when applications generate data in chunks, the Iodine server collects all output into a buffer and sends it only after completion, making true streaming impossible. To solve this, the project introduces native HTTP streaming using chunked transfer encoding across both Iodine (C layer) and Rage (Ruby layer). A new streaming path will be added to Iodine to support incremental writes with a robust backpressure mechanism, ensuring the event loop remains non-blocking. On the Rage side, a developer-friendly API (render stream:) will be implemented using enumerators and fibers, allowing applications to stream data declaratively while seamlessly handling pause/resume behaviour under backpressure. The deliverables include implementing the http_stream transport, a Rack-compatible streaming writer with lifecycle and backpressure management, and the Rage streaming API. The project will also provide integration tests, edge-case handling (e.g., disconnects, high load), and updated documentation. This enables real-time streaming in Rage while preserving compatibility and supporting future extensions like HTTP/2.
Symbolic integration is one of the central capabilities of any advanced calculator system e.g. Mathematica. SymPy currently provides several integration strategies including heuristic methods, algorithmic approaches such as the Risch algorithm, and a rule-based integrator implemented in sympy.integrals.manualintegrate. The manualintegrate module performs integration by recursively applying pattern-based rules similar to how integrals are solved manually. While this approach produces readable step-by-step results and supports a wide range of expressions, its current rule coverage is limited and many integrals involving special functions or structured products are not recognized. The goal of this project is to extend the rule-based integration system in manualintegrate, focusing on improving support for special functions, structured products, and rule prioritization. The project will expand the set of integration rules, improve heuristics for rule selection, and ensure better compatibility with SymPy's symbolic simplification system. The approach is to first analyze the gaps between manualintegrate and more comprehensive rule-based systems such as RUBI in order to identify missing classes of integrals and structural weaknesses. Based on this analysis, the project will design SymPy-compatible rule representations using its existing pattern-matching framework, ensuring consistency with the current architecture. New rules will then be implemented incrementally, with each addition accompanied by rigorous testing and validation to guarantee correctness and stability. Throughout this process, particular attention will be given to preserving and extending SymPy’s step-by-step explanation capability, ensuring that all newly supported integrals remain interpretable and aligned with human-style symbolic reasoning. The end goal is to make SymPy’s integrator more complete, explainable, and closer to human-style symbolic reasoning, while maintaining correctness.
Automatic Differentiation(AD) is a set of techniques to evaluate the derivative of functions specified by a computer program. Clad is a Clang-based automatic differentiation tool that transforms C++ source code to compute derivatives. Clad have demonstrated promising support for GPU-based differentiation through prior efforts involving CUDA, Thrust, and integrations with applications such as XSBench and LULESH. However, all this works remains fragmented and inconsistently tested. This project aims to consolidate the fragmented work and advance Clad’s GPU infrastructure into a robust and consistent system.